diff --git a/MementoMori.py b/MementoMori.py
index f7fbf55..b5f3371 100644
--- a/MementoMori.py
+++ b/MementoMori.py
@@ -1,2 +1,14 @@
 # It is not that we have a short time to live, but that we waste a lot of it. Life is long enough, and a sufficiently generous amount has been given to us for the highest achievements if it were all well invested
-# SENECA
\ No newline at end of file
+# SENECA
+
+from kivy.app import App
+from kivy.uix.widget import Widget
+
+class PongGame(Widget):
+    pass
+
+class TestApp(App):
+    def build(self):
+        return PongGame()
+
+TestApp().run()
\ No newline at end of file
diff --git a/kivy/__init__.py b/kivy/__init__.py
new file mode 100644
index 0000000..8800f18
--- /dev/null
+++ b/kivy/__init__.py
@@ -0,0 +1,516 @@
+'''
+Kivy framework
+==============
+
+Kivy is an open source library for developing multi-touch applications. It is
+cross-platform (Linux/OSX/Windows/Android/iOS) and released under
+the terms of the `MIT License <https://en.wikipedia.org/wiki/MIT_License>`_.
+
+It comes with native support for many multi-touch input devices, a growing
+library of multi-touch aware widgets and hardware accelerated OpenGL drawing.
+Kivy is designed to let you focus on building custom and highly interactive
+applications as quickly and easily as possible.
+
+With Kivy, you can take full advantage of the dynamic nature of Python. There
+are thousands of high-quality, free libraries that can be integrated in your
+application. At the same time, performance-critical parts are implemented
+using `Cython <http://cython.org/>`_.
+
+See http://kivy.org for more information.
+'''
+
+__all__ = (
+    'require', 'parse_kivy_version',
+    'kivy_configure', 'kivy_register_post_configuration',
+    'kivy_options', 'kivy_base_dir',
+    'kivy_modules_dir', 'kivy_data_dir', 'kivy_shader_dir',
+    'kivy_icons_dir', 'kivy_home_dir',
+    'kivy_config_fn', 'kivy_usermodules_dir', 'kivy_examples_dir'
+)
+
+import sys
+import shutil
+from getopt import getopt, GetoptError
+import os
+from os import environ, mkdir
+from os.path import dirname, join, basename, exists, expanduser
+import pkgutil
+import re
+from kivy.logger import Logger, LOG_LEVELS
+from kivy.utils import platform
+from kivy._version import __version__, RELEASE as _KIVY_RELEASE, \
+    _kivy_git_hash, _kivy_build_date
+
+# internals for post-configuration
+__kivy_post_configuration = []
+
+
+if platform == 'macosx' and sys.maxsize < 9223372036854775807:
+    r = '''Unsupported Python version detected!:
+    Kivy requires a 64 bit version of Python to run on OS X. We strongly
+    advise you to use the version of Python that is provided by Apple
+    (don't use ports, fink or homebrew unless you know what you're
+    doing).
+    See http://kivy.org/docs/installation/installation-macosx.html for
+    details.
+    '''
+    Logger.critical(r)
+
+if sys.version_info[0] == 2:
+    Logger.critical(
+        'Unsupported Python version detected!: Kivy 2.0.0 and higher does not '
+        'support Python 2. Please upgrade to Python 3, or downgrade Kivy to '
+        '1.11.0 - the last Kivy release that still supports Python 2.')
+
+
+def parse_kivy_version(version):
+    """Parses the kivy version as described in :func:`require` into a 3-tuple
+    of ([x, y, z], 'rc|a|b|dev|post', 'N') where N is the tag revision. The
+    last two elements may be None.
+    """
+    m = re.match(
+        '^([0-9]+)\\.([0-9]+)\\.([0-9]+?)(rc|a|b|\\.dev|\\.post)?([0-9]+)?$',
+        version)
+    if m is None:
+        raise Exception('Revision format must be X.Y.Z[-tag]')
+
+    major, minor, micro, tag, tagrev = m.groups()
+    if tag == '.dev':
+        tag = 'dev'
+    if tag == '.post':
+        tag = 'post'
+    return [int(major), int(minor), int(micro)], tag, tagrev
+
+
+def require(version):
+    '''Require can be used to check the minimum version required to run a Kivy
+    application. For example, you can start your application code like this::
+
+        import kivy
+        kivy.require('1.0.1')
+
+    If a user attempts to run your application with a version of Kivy that is
+    older than the specified version, an Exception is raised.
+
+    The Kivy version string is built like this::
+
+        X.Y.Z[tag[tagrevision]]
+
+        X is the major version
+        Y is the minor version
+        Z is the bugfixes revision
+
+    The tag is optional, but may be one of '.dev', '.post', 'a', 'b', or 'rc'.
+    The tagrevision is the revision number of the tag.
+
+    .. warning::
+
+        You must not ask for a version with a tag, except -dev. Asking for a
+        'dev' version will just warn the user if the current Kivy
+        version is not a -dev, but it will never raise an exception.
+        You must not ask for a version with a tagrevision.
+
+    '''
+
+    # user version
+    revision, tag, tagrev = parse_kivy_version(version)
+    # current version
+    sysrevision, systag, systagrev = parse_kivy_version(__version__)
+
+    if tag and not systag:
+        Logger.warning('Application requested a dev version of Kivy. '
+                       '(You have %s, but the application requires %s)' % (
+                           __version__, version))
+    # not tag rev (-alpha-1, -beta-x) allowed.
+    if tagrev is not None:
+        raise Exception('Revision format must not contain any tagrevision')
+
+    # finally, checking revision
+    if sysrevision < revision:
+        raise Exception('The version of Kivy installed on this system '
+                        'is too old. '
+                        '(You have %s, but the application requires %s)' % (
+                            __version__, version))
+
+
+def kivy_configure():
+    '''Call post-configuration of Kivy.
+    This function must be called if you create the window yourself.
+    '''
+    for callback in __kivy_post_configuration:
+        callback()
+
+
+def get_includes():
+    '''Retrieves the directories containing includes needed to build new Cython
+    modules with Kivy as a dependency. Currently returns the location of the
+    kivy.graphics module.
+
+    .. versionadded:: 1.9.1
+    '''
+    root_dir = dirname(__file__)
+    return [join(root_dir, 'graphics'), join(root_dir, 'tools', 'gles_compat'),
+            join(root_dir, 'include')]
+
+
+def kivy_register_post_configuration(callback):
+    '''Register a function to be called when kivy_configure() is called.
+
+    .. warning::
+        Internal use only.
+    '''
+    __kivy_post_configuration.append(callback)
+
+
+def kivy_usage():
+    '''Kivy Usage: %s [KIVY OPTION...] [-- PROGRAM OPTIONS]::
+
+            Options placed after a '-- ' separator, will not be touched by kivy,
+            and instead passed to your program.
+
+            Set KIVY_NO_ARGS=1 in your environment or before you import Kivy to
+            disable Kivy's argument parser.
+
+        -h, --help
+            Prints this help message.
+        -d, --debug
+            Shows debug log.
+        -a, --auto-fullscreen
+            Force 'auto' fullscreen mode (no resolution change).
+            Uses your display's resolution. This is most likely what you want.
+        -c, --config section:key[:value]
+            Set a custom [section] key=value in the configuration object.
+        -f, --fullscreen
+            Force running in fullscreen mode.
+        -k, --fake-fullscreen
+            Force 'fake' fullscreen mode (no window border/decoration).
+            Uses the resolution specified by width and height in your config.
+        -w, --windowed
+            Force running in a window.
+        -p, --provider id:provider[,options]
+            Add an input provider (eg: ccvtable1:tuio,192.168.0.1:3333).
+        -m mod, --module=mod
+            Activate a module (use "list" to get a list of available modules).
+        -r, --rotation
+            Rotate the window's contents (0, 90, 180, 270).
+        -s, --save
+            Save current Kivy configuration.
+        --size=640x480
+            Size of window geometry.
+        --dpi=96
+            Manually overload the Window DPI (for testing only.)
+    '''
+    print(kivy_usage.__doc__ % (basename(sys.argv[0])))
+
+
+#: Global settings options for kivy
+kivy_options = {
+    'window': ('egl_rpi', 'sdl2', 'pygame', 'sdl', 'x11'),
+    'text': ('pil', 'sdl2', 'pygame', 'sdlttf'),
+    'video': (
+        'gstplayer', 'ffmpeg', 'ffpyplayer', 'null'),
+    'audio': (
+        'gstplayer', 'pygame', 'ffpyplayer', 'sdl2',
+        'avplayer'),
+    'image': ('tex', 'imageio', 'dds', 'sdl2', 'pygame', 'pil', 'ffpy', 'gif'),
+    'camera': ('opencv', 'gi', 'avfoundation',
+               'android', 'picamera'),
+    'spelling': ('enchant', 'osxappkit', ),
+    'clipboard': (
+        'android', 'winctypes', 'xsel', 'xclip', 'dbusklipper', 'nspaste',
+        'sdl2', 'pygame', 'dummy', 'gtk3', )}
+
+# Read environment
+for option in kivy_options:
+    key = 'KIVY_%s' % option.upper()
+    if key in environ:
+        try:
+            if type(kivy_options[option]) in (list, tuple):
+                kivy_options[option] = environ[key].split(',')
+            else:
+                kivy_options[option] = environ[key].lower() in \
+                    ('true', '1', 'yes')
+        except Exception:
+            Logger.warning('Core: Wrong value for %s environment key' % key)
+            Logger.exception('')
+
+# Extract all needed path in kivy
+#: Kivy directory
+kivy_base_dir = dirname(sys.modules[__name__].__file__)
+#: Kivy modules directory
+
+kivy_modules_dir = environ.get('KIVY_MODULES_DIR',
+                               join(kivy_base_dir, 'modules'))
+#: Kivy data directory
+kivy_data_dir = environ.get('KIVY_DATA_DIR',
+                            join(kivy_base_dir, 'data'))
+#: Kivy binary deps directory
+kivy_binary_deps_dir = environ.get('KIVY_BINARY_DEPS',
+                                   join(kivy_base_dir, 'binary_deps'))
+#: Kivy glsl shader directory
+kivy_shader_dir = join(kivy_data_dir, 'glsl')
+#: Kivy icons config path (don't remove the last '')
+kivy_icons_dir = join(kivy_data_dir, 'icons', '')
+#: Kivy user-home storage directory
+kivy_home_dir = ''
+#: Kivy configuration filename
+kivy_config_fn = ''
+#: Kivy user modules directory
+kivy_usermodules_dir = ''
+#: Kivy examples directory
+kivy_examples_dir = ''
+for examples_dir in (
+        join(dirname(dirname(__file__)), 'examples'),
+        join(sys.exec_prefix, 'share', 'kivy-examples'),
+        join(sys.prefix, 'share', 'kivy-examples'),
+        '/usr/share/kivy-examples', '/usr/local/share/kivy-examples',
+        expanduser('~/.local/share/kivy-examples')):
+    if exists(examples_dir):
+        kivy_examples_dir = examples_dir
+        break
+
+
+def _patch_mod_deps_win(dep_mod, mod_name):
+    import site
+    dep_bins = []
+
+    for d in [sys.prefix, site.USER_BASE]:
+        p = join(d, 'share', mod_name, 'bin')
+        if os.path.isdir(p):
+            os.environ["PATH"] = p + os.pathsep + os.environ["PATH"]
+            if hasattr(os, 'add_dll_directory'):
+                os.add_dll_directory(p)
+            dep_bins.append(p)
+
+    dep_mod.dep_bins = dep_bins
+
+
+# if there are deps, import them so they can do their magic.
+_packages = []
+try:
+    from kivy import deps as old_deps
+    for importer, modname, ispkg in pkgutil.iter_modules(old_deps.__path__):
+        if not ispkg:
+            continue
+        if modname.startswith('gst'):
+            _packages.insert(0, (importer, modname, 'kivy.deps'))
+        else:
+            _packages.append((importer, modname, 'kivy.deps'))
+except ImportError:
+    pass
+
+try:
+    import kivy_deps
+    for importer, modname, ispkg in pkgutil.iter_modules(kivy_deps.__path__):
+        if not ispkg:
+            continue
+        if modname.startswith('gst'):
+            _packages.insert(0, (importer, modname, 'kivy_deps'))
+        else:
+            _packages.append((importer, modname, 'kivy_deps'))
+except ImportError:
+    pass
+
+_logging_msgs = []
+for importer, modname, package in _packages:
+    try:
+        mod = importer.find_module(modname).load_module(modname)
+
+        version = ''
+        if hasattr(mod, '__version__'):
+            version = ' {}'.format(mod.__version__)
+        _logging_msgs.append(
+            'deps: Successfully imported "{}.{}"{}'.
+            format(package, modname, version))
+
+        if modname.startswith('gst') and version == '0.3.3':
+            _patch_mod_deps_win(mod, modname)
+
+    except ImportError as e:
+        Logger.warning(
+            'deps: Error importing dependency "{}.{}": {}'.
+            format(package, modname, str(e)))
+
+# Don't go further if we generate documentation
+if any(name in sys.argv[0] for name in (
+        'sphinx-build', 'autobuild.py', 'sphinx'
+)):
+    environ['KIVY_DOC'] = '1'
+if 'sphinx-build' in sys.argv[0]:
+    environ['KIVY_DOC_INCLUDE'] = '1'
+if any(('nosetests' in arg or 'pytest' in arg) for arg in sys.argv):
+    environ['KIVY_UNITTEST'] = '1'
+if any('pyinstaller' in arg.lower() for arg in sys.argv):
+    environ['KIVY_PACKAGING'] = '1'
+
+if not environ.get('KIVY_DOC_INCLUDE'):
+    # Configuration management
+    if 'KIVY_HOME' in environ:
+        kivy_home_dir = expanduser(environ['KIVY_HOME'])
+    else:
+        user_home_dir = expanduser('~')
+        if platform == 'android':
+            user_home_dir = environ['ANDROID_APP_PATH']
+        elif platform == 'ios':
+            user_home_dir = join(expanduser('~'), 'Documents')
+        kivy_home_dir = join(user_home_dir, '.kivy')
+
+    kivy_config_fn = join(kivy_home_dir, 'config.ini')
+    kivy_usermodules_dir = join(kivy_home_dir, 'mods')
+    icon_dir = join(kivy_home_dir, 'icon')
+
+    if 'KIVY_NO_CONFIG' not in environ:
+        if not exists(kivy_home_dir):
+            mkdir(kivy_home_dir)
+        if not exists(kivy_usermodules_dir):
+            mkdir(kivy_usermodules_dir)
+        if not exists(icon_dir):
+            try:
+                shutil.copytree(join(kivy_data_dir, 'logo'), icon_dir)
+            except:
+                Logger.exception('Error when copying logo directory')
+
+    # configuration
+    from kivy.config import Config
+
+    # Set level of logger
+    level = LOG_LEVELS.get(Config.get('kivy', 'log_level'))
+    Logger.setLevel(level=level)
+
+    # Can be overridden in command line
+    if ('KIVY_UNITTEST' not in environ and
+            'KIVY_PACKAGING' not in environ and
+            environ.get('KIVY_NO_ARGS', "false") not in ('true', '1', 'yes')):
+        # save sys argv, otherwise, gstreamer use it and display help..
+        sys_argv = sys.argv
+        sys.argv = sys.argv[:1]
+
+        try:
+            opts, args = getopt(sys_argv[1:], 'hp:fkawFem:sr:dc:', [
+                'help', 'fullscreen', 'windowed', 'fps', 'event',
+                'module=', 'save', 'fake-fullscreen', 'auto-fullscreen',
+                'multiprocessing-fork', 'display=', 'size=', 'rotate=',
+                'config=', 'debug', 'dpi='])
+
+        except GetoptError as err:
+            Logger.error('Core: %s' % str(err))
+            kivy_usage()
+            sys.exit(2)
+
+        mp_fork = None
+        try:
+            for opt, arg in opts:
+                if opt == '--multiprocessing-fork':
+                    mp_fork = True
+                    break
+        except:
+            pass
+
+        # set argv to the non-read args
+        sys.argv = sys_argv[0:1] + args
+        if mp_fork is not None:
+            # Needs to be first opt for support_freeze to work
+            sys.argv.insert(1, '--multiprocessing-fork')
+
+    else:
+        opts = []
+        args = []
+
+    need_save = False
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            kivy_usage()
+            sys.exit(0)
+        elif opt in ('-p', '--provider'):
+            try:
+                pid, args = arg.split(':', 1)
+                Config.set('input', pid, args)
+            except ValueError:
+                # when we are doing an executable on macosx with
+                # pyinstaller, they are passing information with -p. so
+                # it will conflict with our current -p option. since the
+                # format is not the same, just avoid it.
+                pass
+        elif opt in ('-a', '--auto-fullscreen'):
+            Config.set('graphics', 'fullscreen', 'auto')
+        elif opt in ('-c', '--config'):
+            ol = arg.split(':', 2)
+            if len(ol) == 2:
+                Config.set(ol[0], ol[1], '')
+            elif len(ol) == 3:
+                Config.set(ol[0], ol[1], ol[2])
+            else:
+                raise Exception('Invalid --config value')
+            if ol[0] == 'kivy' and ol[1] == 'log_level':
+                level = LOG_LEVELS.get(Config.get('kivy', 'log_level'))
+                Logger.setLevel(level=level)
+        elif opt in ('-k', '--fake-fullscreen'):
+            Config.set('graphics', 'fullscreen', 'fake')
+        elif opt in ('-f', '--fullscreen'):
+            Config.set('graphics', 'fullscreen', '1')
+        elif opt in ('-w', '--windowed'):
+            Config.set('graphics', 'fullscreen', '0')
+        elif opt in ('--size', ):
+            w, h = str(arg).split('x')
+            Config.set('graphics', 'width', w)
+            Config.set('graphics', 'height', h)
+        elif opt in ('--display', ):
+            Config.set('graphics', 'display', str(arg))
+        elif opt in ('-m', '--module'):
+            if str(arg) == 'list':
+                from kivy.modules import Modules
+                Modules.usage_list()
+                sys.exit(0)
+            args = arg.split(':', 1)
+            if len(args) == 1:
+                args += ['']
+            Config.set('modules', args[0], args[1])
+        elif opt in ('-s', '--save'):
+            need_save = True
+        elif opt in ('-r', '--rotation'):
+            Config.set('graphics', 'rotation', arg)
+        elif opt in ('-d', '--debug'):
+            level = LOG_LEVELS.get('debug')
+            Logger.setLevel(level=level)
+        elif opt == '--dpi':
+            environ['KIVY_DPI'] = arg
+
+    if need_save and 'KIVY_NO_CONFIG' not in environ:
+        try:
+            with open(kivy_config_fn, 'w') as fd:
+                Config.write(fd)
+        except Exception as e:
+            Logger.exception('Core: error while saving default'
+                             'configuration file:', str(e))
+        Logger.info('Core: Kivy configuration saved.')
+        sys.exit(0)
+
+    # configure all activated modules
+    from kivy.modules import Modules
+    Modules.configure()
+
+    # android hooks: force fullscreen and add android touch input provider
+    if platform in ('android', 'ios'):
+        from kivy.config import Config
+        Config.set('graphics', 'fullscreen', 'auto')
+        Config.remove_section('input')
+        Config.add_section('input')
+
+    if platform == 'android':
+        Config.set('input', 'androidtouch', 'android')
+
+for msg in _logging_msgs:
+    Logger.info(msg)
+
+if not _KIVY_RELEASE and _kivy_git_hash and _kivy_build_date:
+    Logger.info('Kivy: v%s, git-%s, %s' % (
+        __version__, _kivy_git_hash[:7], _kivy_build_date))
+else:
+    Logger.info('Kivy: v%s' % __version__)
+Logger.info('Kivy: Installed at "{}"'.format(__file__))
+Logger.info('Python: v{}'.format(sys.version))
+Logger.info('Python: Interpreter at "{}"'.format(sys.executable))
+
+from kivy.logger import file_log_handler
+if file_log_handler is not None:
+    file_log_handler.purge_logs()
diff --git a/kivy/__pycache__/__init__.cpython-310.pyc b/kivy/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..5fe1e1c
Binary files /dev/null and b/kivy/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/__pycache__/_version.cpython-310.pyc b/kivy/__pycache__/_version.cpython-310.pyc
new file mode 100644
index 0000000..28097e9
Binary files /dev/null and b/kivy/__pycache__/_version.cpython-310.pyc differ
diff --git a/kivy/__pycache__/animation.cpython-310.pyc b/kivy/__pycache__/animation.cpython-310.pyc
new file mode 100644
index 0000000..fc28fe5
Binary files /dev/null and b/kivy/__pycache__/animation.cpython-310.pyc differ
diff --git a/kivy/__pycache__/app.cpython-310.pyc b/kivy/__pycache__/app.cpython-310.pyc
new file mode 100644
index 0000000..687c9b4
Binary files /dev/null and b/kivy/__pycache__/app.cpython-310.pyc differ
diff --git a/kivy/__pycache__/atlas.cpython-310.pyc b/kivy/__pycache__/atlas.cpython-310.pyc
new file mode 100644
index 0000000..4ea5363
Binary files /dev/null and b/kivy/__pycache__/atlas.cpython-310.pyc differ
diff --git a/kivy/__pycache__/base.cpython-310.pyc b/kivy/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000..0d10618
Binary files /dev/null and b/kivy/__pycache__/base.cpython-310.pyc differ
diff --git a/kivy/__pycache__/cache.cpython-310.pyc b/kivy/__pycache__/cache.cpython-310.pyc
new file mode 100644
index 0000000..97173ad
Binary files /dev/null and b/kivy/__pycache__/cache.cpython-310.pyc differ
diff --git a/kivy/__pycache__/clock.cpython-310.pyc b/kivy/__pycache__/clock.cpython-310.pyc
new file mode 100644
index 0000000..95f6834
Binary files /dev/null and b/kivy/__pycache__/clock.cpython-310.pyc differ
diff --git a/kivy/__pycache__/compat.cpython-310.pyc b/kivy/__pycache__/compat.cpython-310.pyc
new file mode 100644
index 0000000..69df9db
Binary files /dev/null and b/kivy/__pycache__/compat.cpython-310.pyc differ
diff --git a/kivy/__pycache__/config.cpython-310.pyc b/kivy/__pycache__/config.cpython-310.pyc
new file mode 100644
index 0000000..2b98289
Binary files /dev/null and b/kivy/__pycache__/config.cpython-310.pyc differ
diff --git a/kivy/__pycache__/context.cpython-310.pyc b/kivy/__pycache__/context.cpython-310.pyc
new file mode 100644
index 0000000..54bdaf1
Binary files /dev/null and b/kivy/__pycache__/context.cpython-310.pyc differ
diff --git a/kivy/__pycache__/event.cpython-310.pyc b/kivy/__pycache__/event.cpython-310.pyc
new file mode 100644
index 0000000..39b58e5
Binary files /dev/null and b/kivy/__pycache__/event.cpython-310.pyc differ
diff --git a/kivy/__pycache__/factory.cpython-310.pyc b/kivy/__pycache__/factory.cpython-310.pyc
new file mode 100644
index 0000000..355730a
Binary files /dev/null and b/kivy/__pycache__/factory.cpython-310.pyc differ
diff --git a/kivy/__pycache__/factory_registers.cpython-310.pyc b/kivy/__pycache__/factory_registers.cpython-310.pyc
new file mode 100644
index 0000000..dfd687c
Binary files /dev/null and b/kivy/__pycache__/factory_registers.cpython-310.pyc differ
diff --git a/kivy/__pycache__/geometry.cpython-310.pyc b/kivy/__pycache__/geometry.cpython-310.pyc
new file mode 100644
index 0000000..23ed951
Binary files /dev/null and b/kivy/__pycache__/geometry.cpython-310.pyc differ
diff --git a/kivy/__pycache__/gesture.cpython-310.pyc b/kivy/__pycache__/gesture.cpython-310.pyc
new file mode 100644
index 0000000..f089e90
Binary files /dev/null and b/kivy/__pycache__/gesture.cpython-310.pyc differ
diff --git a/kivy/__pycache__/interactive.cpython-310.pyc b/kivy/__pycache__/interactive.cpython-310.pyc
new file mode 100644
index 0000000..ab10bb5
Binary files /dev/null and b/kivy/__pycache__/interactive.cpython-310.pyc differ
diff --git a/kivy/__pycache__/loader.cpython-310.pyc b/kivy/__pycache__/loader.cpython-310.pyc
new file mode 100644
index 0000000..68191f2
Binary files /dev/null and b/kivy/__pycache__/loader.cpython-310.pyc differ
diff --git a/kivy/__pycache__/logger.cpython-310.pyc b/kivy/__pycache__/logger.cpython-310.pyc
new file mode 100644
index 0000000..4f845a2
Binary files /dev/null and b/kivy/__pycache__/logger.cpython-310.pyc differ
diff --git a/kivy/__pycache__/metrics.cpython-310.pyc b/kivy/__pycache__/metrics.cpython-310.pyc
new file mode 100644
index 0000000..ee7a685
Binary files /dev/null and b/kivy/__pycache__/metrics.cpython-310.pyc differ
diff --git a/kivy/__pycache__/multistroke.cpython-310.pyc b/kivy/__pycache__/multistroke.cpython-310.pyc
new file mode 100644
index 0000000..06e43f7
Binary files /dev/null and b/kivy/__pycache__/multistroke.cpython-310.pyc differ
diff --git a/kivy/__pycache__/parser.cpython-310.pyc b/kivy/__pycache__/parser.cpython-310.pyc
new file mode 100644
index 0000000..b788e8b
Binary files /dev/null and b/kivy/__pycache__/parser.cpython-310.pyc differ
diff --git a/kivy/__pycache__/resources.cpython-310.pyc b/kivy/__pycache__/resources.cpython-310.pyc
new file mode 100644
index 0000000..a51c2a3
Binary files /dev/null and b/kivy/__pycache__/resources.cpython-310.pyc differ
diff --git a/kivy/__pycache__/setupconfig.cpython-310.pyc b/kivy/__pycache__/setupconfig.cpython-310.pyc
new file mode 100644
index 0000000..458c5ab
Binary files /dev/null and b/kivy/__pycache__/setupconfig.cpython-310.pyc differ
diff --git a/kivy/__pycache__/support.cpython-310.pyc b/kivy/__pycache__/support.cpython-310.pyc
new file mode 100644
index 0000000..c9dd93d
Binary files /dev/null and b/kivy/__pycache__/support.cpython-310.pyc differ
diff --git a/kivy/__pycache__/utils.cpython-310.pyc b/kivy/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000..f97758e
Binary files /dev/null and b/kivy/__pycache__/utils.cpython-310.pyc differ
diff --git a/kivy/__pycache__/vector.cpython-310.pyc b/kivy/__pycache__/vector.cpython-310.pyc
new file mode 100644
index 0000000..73374f4
Binary files /dev/null and b/kivy/__pycache__/vector.cpython-310.pyc differ
diff --git a/kivy/__pycache__/weakmethod.cpython-310.pyc b/kivy/__pycache__/weakmethod.cpython-310.pyc
new file mode 100644
index 0000000..9ade6b5
Binary files /dev/null and b/kivy/__pycache__/weakmethod.cpython-310.pyc differ
diff --git a/kivy/_clock.cpython-310-x86_64-linux-gnu.so b/kivy/_clock.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..dfac127
Binary files /dev/null and b/kivy/_clock.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/_clock.pxd b/kivy/_clock.pxd
new file mode 100644
index 0000000..6dd96ba
--- /dev/null
+++ b/kivy/_clock.pxd
@@ -0,0 +1,131 @@
+
+cdef class ClockEvent(object):
+
+    cdef int _is_triggered
+    cdef public ClockEvent next
+    '''The next :class:`ClockEvent` in order they were scheduled.
+    '''
+    cdef public ClockEvent prev
+    '''The previous :class:`ClockEvent` in order they were scheduled.
+    '''
+    cdef public object cid
+    cdef public CyClockBase clock
+    '''The :class:`CyClockBase` instance associated with the event.
+    '''
+    cdef public int loop
+    '''Whether this event repeats at intervals of :attr:`timeout`.
+    '''
+    cdef public object weak_callback
+    cdef public object callback
+    cdef public double timeout
+    '''The duration after scheduling when the callback should be executed.
+    '''
+    cdef public double _last_dt
+    cdef public double _dt
+    cdef public list _del_queue
+
+    cdef public object clock_ended_callback
+    """A Optional callback for this event, which if provided is called by the clock
+    when the clock is stopped and the event was not ticked.
+    """
+    cdef public object weak_clock_ended_callback
+
+    cdef public int release_ref
+    """If True, the event should never release the reference to the callbacks.
+    If False, a weakref may be created instead.
+    """
+
+    cpdef get_callback(self)
+    cpdef get_clock_ended_callback(self)
+    cpdef cancel(self)
+    cpdef release(self)
+    cpdef tick(self, double curtime)
+
+
+cdef class FreeClockEvent(ClockEvent):
+
+    cdef public int free
+    '''Whether this event was scheduled as a free event.
+    '''
+
+
+cdef class CyClockBase(object):
+
+    cdef public double _last_tick
+    cdef public int max_iteration
+    '''The maximum number of callback iterations at the end of the frame, before the next
+    frame. If more iterations occur, a warning is issued.
+    '''
+
+    cdef public double clock_resolution
+    '''If the remaining time until the event timeout is less than :attr:`clock_resolution`,
+    the clock will execute the callback even if it hasn't exactly timed out.
+
+    If -1, the default, the resolution will be computed from config's ``maxfps``.
+    Otherwise, the provided value is used. Defaults to -1.
+    '''
+
+    cdef public double _max_fps
+
+    cdef public ClockEvent _root_event
+    '''The first event in the chain. Can be None.
+    '''
+    cdef public ClockEvent _next_event
+    '''During frame processing when we service the events, this points to the next
+    event that will be processed. After ticking an event, we continue with
+    :attr:`_next_event`.
+
+    If a event that is canceled is the :attr:`_next_event`, :attr:`_next_event`
+    is shifted to point to the after after this, or None if it's at the end of the
+    chain.
+    '''
+    cdef public ClockEvent _cap_event
+    '''The cap event is the last event in the chain for each frame.
+    For a particular frame, events may be added dynamically after this event,
+    and the current frame should not process them.
+
+    Similarly to :attr:`_next_event`,
+    when canceling the :attr:`_cap_event`, :attr:`_cap_event` is shifted to the
+    one previous to it.
+    '''
+    cdef public ClockEvent _last_event
+    '''The last event in the chain. New events are added after this. Can be None.
+    '''
+    cdef public object _lock
+    cdef public object _lock_acquire
+    cdef public object _lock_release
+
+    cdef public int has_started
+    cdef public int has_ended
+    cdef public object _del_safe_lock
+    cdef public int _del_safe_done
+
+    cpdef get_resolution(self)
+    cpdef ClockEvent create_lifecycle_aware_trigger(
+        self, callback, clock_ended_callback, timeout=*, interval=*, release_ref=*)
+    cpdef ClockEvent create_trigger(self, callback, timeout=*, interval=*, release_ref=*)
+    cpdef schedule_lifecycle_aware_del_safe(self, callback, clock_ended_callback)
+    cpdef schedule_del_safe(self, callback)
+    cpdef ClockEvent schedule_once(self, callback, timeout=*)
+    cpdef ClockEvent schedule_interval(self, callback, timeout)
+    cpdef unschedule(self, callback, all=*)
+    cpdef _release_references(self)
+    cpdef _process_del_safe_events(self)
+    cpdef _process_events(self)
+    cpdef _process_events_before_frame(self)
+    cpdef get_min_timeout(self)
+    cpdef get_events(self)
+    cpdef get_before_frame_events(self)
+    cpdef _process_clock_ended_del_safe_events(self)
+    cpdef _process_clock_ended_callbacks(self)
+
+
+cdef class CyClockBaseFree(CyClockBase):
+
+    cpdef FreeClockEvent create_lifecycle_aware_trigger_free(
+        self, callback, clock_ended_callback, timeout=*, interval=*, release_ref=*)
+    cpdef FreeClockEvent create_trigger_free(self, callback, timeout=*, interval=*, release_ref=*)
+    cpdef FreeClockEvent schedule_once_free(self, callback, timeout=*)
+    cpdef FreeClockEvent schedule_interval_free(self, callback, timeout)
+    cpdef _process_free_events(self, double last_tick)
+    cpdef get_min_free_timeout(self)
diff --git a/kivy/_event.cpython-310-x86_64-linux-gnu.so b/kivy/_event.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..0e48f41
Binary files /dev/null and b/kivy/_event.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/_event.pxd b/kivy/_event.pxd
new file mode 100644
index 0000000..502f681
--- /dev/null
+++ b/kivy/_event.pxd
@@ -0,0 +1,68 @@
+from cpython.ref cimport PyObject
+
+cdef dict cache_properties_per_cls
+
+cdef class ObjectWithUid(object):
+    cdef readonly int uid
+
+
+cdef class Observable(ObjectWithUid):
+    cdef object __fbind_mapping
+    cdef object bound_uid
+
+
+cdef class EventDispatcher(ObjectWithUid):
+    cdef dict __event_stack
+    cdef dict __properties
+    cdef dict __storage
+    cdef object __weakref__
+    cdef public set _kwargs_applied_init
+    cdef public object _proxy_ref
+    cpdef dict properties(self)
+
+
+cdef enum BoundLock:
+    # the state of the BoundCallback, i.e. whether it can be deleted
+    unlocked  # whether the BoundCallback is unlocked and can be deleted
+    locked  # whether the BoundCallback is locked and cannot be deleted
+    deleted  # whether the locked BoundCallback was marked for deletion
+
+cdef class BoundCallback:
+    cdef object func
+    cdef tuple largs
+    cdef dict kwargs
+    cdef int is_ref  # if func is a ref to the function
+    cdef BoundLock lock  # see BoundLock
+    cdef BoundCallback next  # next callback in chain
+    cdef BoundCallback prev  # previous callback in chain
+    cdef object uid  # the uid given for this callback, None if not given
+    cdef EventObservers observers
+
+    cdef void set_largs(self, tuple largs)
+
+
+cdef class EventObservers:
+    # If dispatching should occur in normal or reverse order of binding.
+    cdef int dispatch_reverse
+    # If in dispatch, the value parameter is dispatched or ignored.
+    cdef int dispatch_value
+    # The first callback bound
+    cdef BoundCallback first_callback
+    # The last callback bound
+    cdef BoundCallback last_callback
+    # The uid to assign to the next bound callback.
+    cdef object uid
+
+    cdef inline BoundCallback make_callback(self, object observer, tuple largs, dict kwargs, int is_ref, uid=*)
+    cdef inline void bind(self, object observer, object src_observer, int is_ref) except *
+    cdef inline object fbind(self, object observer, tuple largs, dict kwargs, int is_ref)
+    cdef inline BoundCallback fbind_callback(self, object observer, tuple largs, dict kwargs, int is_ref)
+    cdef inline void fbind_existing_callback(self, BoundCallback callback)
+    cdef inline void unbind(self, object observer, int stop_on_first) except *
+    cdef inline void funbind(self, object observer, tuple largs, dict kwargs) except *
+    cdef inline object unbind_uid(self, object uid)
+    cdef inline object unbind_callback(self, BoundCallback callback)
+    cdef inline void remove_callback(self, BoundCallback callback, int force=*) except *
+    cdef inline object _dispatch(
+        self, object f, tuple slargs, dict skwargs, object obj, object value, tuple largs, dict kwargs)
+    cdef inline int dispatch(self, object obj, object value, tuple largs, dict kwargs, int stop_on_true) except 2
diff --git a/kivy/_metrics.cpython-310-x86_64-linux-gnu.so b/kivy/_metrics.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..9bf17f8
Binary files /dev/null and b/kivy/_metrics.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/_metrics.pxd b/kivy/_metrics.pxd
new file mode 100644
index 0000000..2c14eac
--- /dev/null
+++ b/kivy/_metrics.pxd
@@ -0,0 +1,5 @@
+from kivy._event cimport EventObservers
+
+cdef EventObservers pixel_scale_observers
+
+cpdef float dpi2px(value, str ext) except *
diff --git a/kivy/_version.py b/kivy/_version.py
new file mode 100644
index 0000000..c713fbf
--- /dev/null
+++ b/kivy/_version.py
@@ -0,0 +1,17 @@
+# This file is imported from __init__.py and exec'd from setup.py
+
+MAJOR = 2
+MINOR = 1
+MICRO = 0
+RELEASE = True
+
+__version__ = '%d.%d.%d' % (MAJOR, MINOR, MICRO)
+
+if not RELEASE:
+    # if it's a rcx release, it's not proceeded by a period. If it is a
+    # devx release, it must start with a period
+    __version__ += ''
+
+
+_kivy_git_hash = '023bd79b90f9831b45bb8eb449346648aa5fe5f8'
+_kivy_build_date = '20220306'
diff --git a/kivy/animation.py b/kivy/animation.py
new file mode 100644
index 0000000..2dbff0b
--- /dev/null
+++ b/kivy/animation.py
@@ -0,0 +1,832 @@
+'''
+Animation
+=========
+
+:class:`Animation` and :class:`AnimationTransition` are used to animate
+:class:`~kivy.uix.widget.Widget` properties. You must specify at least a
+property name and target value. To use an Animation, follow these steps:
+
+    * Setup an Animation object
+    * Use the Animation object on a Widget
+
+Simple animation
+----------------
+
+To animate a Widget's x or y position, simply specify the target x/y values
+where you want the widget positioned at the end of the animation::
+
+    anim = Animation(x=100, y=100)
+    anim.start(widget)
+
+The animation will last for 1 second unless :attr:`duration` is specified.
+When anim.start() is called, the Widget will move smoothly from the current
+x/y position to (100, 100).
+
+Multiple properties and transitions
+-----------------------------------
+
+You can animate multiple properties and use built-in or custom transition
+functions using :attr:`transition` (or the `t=` shortcut). For example,
+to animate the position and size using the 'in_quad' transition::
+
+    anim = Animation(x=50, size=(80, 80), t='in_quad')
+    anim.start(widget)
+
+Note that the `t=` parameter can be the string name of a method in the
+:class:`AnimationTransition` class or your own animation function.
+
+Sequential animation
+--------------------
+
+To join animations sequentially, use the '+' operator. The following example
+will animate to x=50 over 1 second, then animate the size to (80, 80) over the
+next two seconds::
+
+    anim = Animation(x=50) + Animation(size=(80, 80), duration=2.)
+    anim.start(widget)
+
+Parallel animation
+------------------
+
+To join animations in parallel, use the '&' operator. The following example
+will animate the position to (80, 10) over 1 second, whilst in parallel
+animating the size to (800, 800)::
+
+    anim = Animation(pos=(80, 10))
+    anim &= Animation(size=(800, 800), duration=2.)
+    anim.start(widget)
+
+Keep in mind that creating overlapping animations on the same property may have
+unexpected results. If you want to apply multiple animations to the same
+property, you should either schedule them sequentially (via the '+' operator or
+using the *on_complete* callback) or cancel previous animations using the
+:attr:`~Animation.cancel_all` method.
+
+Repeating animation
+-------------------
+
+.. versionadded:: 1.8.0
+
+.. note::
+    This is currently only implemented for 'Sequence' animations.
+
+To set an animation to repeat, simply set the :attr:`Sequence.repeat`
+property to `True`::
+
+    anim = Animation(...) + Animation(...)
+    anim.repeat = True
+    anim.start(widget)
+
+For flow control of animations such as stopping and cancelling, use the methods
+already in place in the animation module.
+'''
+
+__all__ = ('Animation', 'AnimationTransition')
+
+from math import sqrt, cos, sin, pi
+from collections import ChainMap
+from kivy.event import EventDispatcher
+from kivy.clock import Clock
+from kivy.compat import string_types, iterkeys
+from kivy.weakproxy import WeakProxy
+
+
+class Animation(EventDispatcher):
+    '''Create an animation definition that can be used to animate a Widget.
+
+    :Parameters:
+        `duration` or `d`: float, defaults to 1.
+            Duration of the animation, in seconds.
+        `transition` or `t`: str or func
+            Transition function for animate properties. It can be the name of a
+            method from :class:`AnimationTransition`.
+        `step` or `s`: float
+            Step in milliseconds of the animation. Defaults to 0, which means
+            the animation is updated for every frame.
+
+            To update the animation less often, set the step value to a float.
+            For example, if you want to animate at 30 FPS, use s=1/30.
+
+    :Events:
+        `on_start`: animation, widget
+            Fired when the animation is started on a widget.
+        `on_complete`: animation, widget
+            Fired when the animation is completed or stopped on a widget.
+        `on_progress`: animation, widget, progression
+            Fired when the progression of the animation is changing.
+
+    .. versionchanged:: 1.4.0
+        Added s/step parameter.
+
+    .. versionchanged:: 1.10.0
+        The default value of the step parameter was changed from 1/60. to 0.
+    '''
+
+    _update_ev = None
+
+    _instances = set()
+
+    __events__ = ('on_start', 'on_progress', 'on_complete')
+
+    def __init__(self, **kw):
+        super().__init__()
+        # Initialize
+        self._clock_installed = False
+        self._duration = kw.pop('d', kw.pop('duration', 1.))
+        self._transition = kw.pop('t', kw.pop('transition', 'linear'))
+        self._step = kw.pop('s', kw.pop('step', 0))
+        if isinstance(self._transition, string_types):
+            self._transition = getattr(AnimationTransition, self._transition)
+        self._animated_properties = kw
+        self._widgets = {}
+
+    @property
+    def duration(self):
+        '''Return the duration of the animation.
+        '''
+        return self._duration
+
+    @property
+    def transition(self):
+        '''Return the transition of the animation.
+        '''
+        return self._transition
+
+    @property
+    def animated_properties(self):
+        '''Return the properties used to animate.
+        '''
+        return self._animated_properties
+
+    @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)
+
+    @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)
+
+    def start(self, widget):
+        '''Start the animation on a widget.
+        '''
+        self.stop(widget)
+        self._initialize(widget)
+        self._register()
+        self.dispatch('on_start', widget)
+
+    def stop(self, widget):
+        '''Stop the animation previously applied to a widget, triggering the
+        `on_complete` event.'''
+        props = self._widgets.pop(widget.uid, None)
+        if props:
+            self.dispatch('on_complete', widget)
+        self.cancel(widget)
+
+    def cancel(self, widget):
+        '''Cancel the animation previously applied to a widget. Same
+        effect as :attr:`stop`, except the `on_complete` event will
+        *not* be triggered!
+
+        .. versionadded:: 1.4.0
+        '''
+        self._widgets.pop(widget.uid, None)
+        self._clock_uninstall()
+        if not self._widgets:
+            self._unregister()
+
+    def stop_property(self, widget, prop):
+        '''Even if an animation is running, remove a property. It will not be
+        animated further. If it was the only/last property being animated,
+        the animation will be stopped (see :attr:`stop`).
+        '''
+        props = self._widgets.get(widget.uid, None)
+        if not props:
+            return
+        props['properties'].pop(prop, None)
+
+        # no more properties to animation ? kill the animation.
+        if not props['properties']:
+            self.stop(widget)
+
+    def cancel_property(self, widget, prop):
+        '''Even if an animation is running, remove a property. It will not be
+        animated further. If it was the only/last property being animated,
+        the animation will be canceled (see :attr:`cancel`)
+
+        .. versionadded:: 1.4.0
+        '''
+        props = self._widgets.get(widget.uid, None)
+        if not props:
+            return
+        props['properties'].pop(prop, None)
+
+        # no more properties to animation ? kill the animation.
+        if not props['properties']:
+            self.cancel(widget)
+
+    def have_properties_to_animate(self, widget):
+        '''Return True if a widget still has properties to animate.
+
+        .. versionadded:: 1.8.0
+        '''
+        props = self._widgets.get(widget.uid, None)
+        if props and props['properties']:
+            return True
+
+    #
+    # Private
+    #
+    def _register(self):
+        Animation._instances.add(self)
+
+    def _unregister(self):
+        if self in Animation._instances:
+            Animation._instances.remove(self)
+
+    def _initialize(self, widget):
+        d = self._widgets[widget.uid] = {
+            'widget': widget,
+            'properties': {},
+            'time': None}
+
+        # get current values
+        p = d['properties']
+        for key, value in self._animated_properties.items():
+            original_value = getattr(widget, key)
+            if isinstance(original_value, (tuple, list)):
+                original_value = original_value[:]
+            elif isinstance(original_value, dict):
+                original_value = original_value.copy()
+            p[key] = (original_value, value)
+
+        # install clock
+        self._clock_install()
+
+    def _clock_install(self):
+        if self._clock_installed:
+            return
+        self._update_ev = Clock.schedule_interval(self._update, self._step)
+        self._clock_installed = True
+
+    def _clock_uninstall(self):
+        if self._widgets or not self._clock_installed:
+            return
+        self._clock_installed = False
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+            self._update_ev = None
+
+    def _update(self, dt):
+        widgets = self._widgets
+        transition = self._transition
+        calculate = self._calculate
+        for uid in list(widgets.keys()):
+            anim = widgets[uid]
+            widget = anim['widget']
+
+            if isinstance(widget, WeakProxy) and not len(dir(widget)):
+                # empty proxy, widget is gone. ref: #2458
+                self._widgets.pop(uid, None)
+                self._clock_uninstall()
+                if not self._widgets:
+                    self._unregister()
+                continue
+
+            if anim['time'] is None:
+                anim['time'] = 0.
+            else:
+                anim['time'] += dt
+
+            # calculate progression
+            if self._duration:
+                progress = min(1., anim['time'] / self._duration)
+            else:
+                progress = 1
+            t = transition(progress)
+
+            # apply progression on widget
+            for key, values in anim['properties'].items():
+                a, b = values
+                value = calculate(a, b, t)
+                setattr(widget, key, value)
+
+            self.dispatch('on_progress', widget, progress)
+
+            # time to stop ?
+            if progress >= 1.:
+                self.stop(widget)
+
+    def _calculate(self, a, b, t):
+        _calculate = self._calculate
+        if isinstance(a, list) or isinstance(a, tuple):
+            if isinstance(a, list):
+                tp = list
+            else:
+                tp = tuple
+            return tp([_calculate(a[x], b[x], t) for x in range(len(a))])
+        elif isinstance(a, dict):
+            d = {}
+            for x in iterkeys(a):
+                if x not in b:
+                    # User requested to animate only part of the dict.
+                    # Copy the rest
+                    d[x] = a[x]
+                else:
+                    d[x] = _calculate(a[x], b[x], t)
+            return d
+        else:
+            return (a * (1. - t)) + (b * t)
+
+    #
+    # Default handlers
+    #
+    def on_start(self, widget):
+        pass
+
+    def on_progress(self, widget, progress):
+        pass
+
+    def on_complete(self, widget):
+        pass
+
+    def __add__(self, animation):
+        return Sequence(self, animation)
+
+    def __and__(self, animation):
+        return Parallel(self, animation)
+
+
+class CompoundAnimation(Animation):
+
+    def stop_property(self, widget, prop):
+        self.anim1.stop_property(widget, prop)
+        self.anim2.stop_property(widget, prop)
+        if (not self.anim1.have_properties_to_animate(widget) and
+                not self.anim2.have_properties_to_animate(widget)):
+            self.stop(widget)
+
+    def cancel(self, widget):
+        self.anim1.cancel(widget)
+        self.anim2.cancel(widget)
+        super().cancel(widget)
+
+    def cancel_property(self, widget, prop):
+        '''Even if an animation is running, remove a property. It will not be
+        animated further. If it was the only/last property being animated,
+        the animation will be canceled (see :attr:`cancel`)
+
+        This method overrides `:class:kivy.animation.Animation`'s
+        version, to cancel it on all animations of the Sequence.
+
+        .. versionadded:: 1.10.0
+        '''
+        self.anim1.cancel_property(widget, prop)
+        self.anim2.cancel_property(widget, prop)
+        if (not self.anim1.have_properties_to_animate(widget) and
+                not self.anim2.have_properties_to_animate(widget)):
+            self.cancel(widget)
+
+    def have_properties_to_animate(self, widget):
+        return (self.anim1.have_properties_to_animate(widget) or
+                self.anim2.have_properties_to_animate(widget))
+
+    @property
+    def animated_properties(self):
+        return ChainMap({},
+                        self.anim2.animated_properties,
+                        self.anim1.animated_properties)
+
+    @property
+    def transition(self):
+        # This property is impossible to implement
+        raise AttributeError(
+            "Can't lookup transition attribute of a CompoundAnimation")
+
+
+class Sequence(CompoundAnimation):
+
+    def __init__(self, anim1, anim2):
+        super().__init__()
+
+        #: Repeat the sequence. See 'Repeating animation' in the header
+        #: documentation.
+        self.repeat = False
+
+        self.anim1 = anim1
+        self.anim2 = anim2
+
+        self.anim1.bind(on_complete=self.on_anim1_complete,
+                        on_progress=self.on_anim1_progress)
+        self.anim2.bind(on_complete=self.on_anim2_complete,
+                        on_progress=self.on_anim2_progress)
+
+    @property
+    def duration(self):
+        return self.anim1.duration + self.anim2.duration
+
+    def stop(self, widget):
+        props = self._widgets.pop(widget.uid, None)
+        self.anim1.stop(widget)
+        self.anim2.stop(widget)
+        if props:
+            self.dispatch('on_complete', widget)
+        super().cancel(widget)
+
+    def start(self, widget):
+        self.stop(widget)
+        self._widgets[widget.uid] = True
+        self._register()
+        self.dispatch('on_start', widget)
+        self.anim1.start(widget)
+
+    def on_anim1_complete(self, instance, widget):
+        if widget.uid not in self._widgets:
+            return
+        self.anim2.start(widget)
+
+    def on_anim1_progress(self, instance, widget, progress):
+        self.dispatch('on_progress', widget, progress / 2.)
+
+    def on_anim2_complete(self, instance, widget):
+        '''Repeating logic used with boolean variable "repeat".
+
+        .. versionadded:: 1.7.1
+        '''
+        if widget.uid not in self._widgets:
+            return
+        if self.repeat:
+            self.anim1.start(widget)
+        else:
+            self.dispatch('on_complete', widget)
+            self.cancel(widget)
+
+    def on_anim2_progress(self, instance, widget, progress):
+        self.dispatch('on_progress', widget, .5 + progress / 2.)
+
+
+class Parallel(CompoundAnimation):
+
+    def __init__(self, anim1, anim2):
+        super().__init__()
+        self.anim1 = anim1
+        self.anim2 = anim2
+
+        self.anim1.bind(on_complete=self.on_anim_complete)
+        self.anim2.bind(on_complete=self.on_anim_complete)
+
+    @property
+    def duration(self):
+        return max(self.anim1.duration, self.anim2.duration)
+
+    def stop(self, widget):
+        self.anim1.stop(widget)
+        self.anim2.stop(widget)
+        if self._widgets.pop(widget.uid, None):
+            self.dispatch('on_complete', widget)
+        super().cancel(widget)
+
+    def start(self, widget):
+        self.stop(widget)
+        self.anim1.start(widget)
+        self.anim2.start(widget)
+        self._widgets[widget.uid] = {'complete': 0}
+        self._register()
+        self.dispatch('on_start', widget)
+
+    def on_anim_complete(self, instance, widget):
+        self._widgets[widget.uid]['complete'] += 1
+        if self._widgets[widget.uid]['complete'] == 2:
+            self.stop(widget)
+
+
+class AnimationTransition:
+    '''Collection of animation functions to be used with the Animation object.
+    Easing Functions ported to Kivy from the Clutter Project
+    https://developer.gnome.org/clutter/stable/ClutterAlpha.html
+
+    The `progress` parameter in each animation function is in the range 0-1.
+    '''
+
+    @staticmethod
+    def linear(progress):
+        '''.. image:: images/anim_linear.png'''
+        return progress
+
+    @staticmethod
+    def in_quad(progress):
+        '''.. image:: images/anim_in_quad.png
+        '''
+        return progress * progress
+
+    @staticmethod
+    def out_quad(progress):
+        '''.. image:: images/anim_out_quad.png
+        '''
+        return -1.0 * progress * (progress - 2.0)
+
+    @staticmethod
+    def in_out_quad(progress):
+        '''.. image:: images/anim_in_out_quad.png
+        '''
+        p = progress * 2
+        if p < 1:
+            return 0.5 * p * p
+        p -= 1.0
+        return -0.5 * (p * (p - 2.0) - 1.0)
+
+    @staticmethod
+    def in_cubic(progress):
+        '''.. image:: images/anim_in_cubic.png
+        '''
+        return progress * progress * progress
+
+    @staticmethod
+    def out_cubic(progress):
+        '''.. image:: images/anim_out_cubic.png
+        '''
+        p = progress - 1.0
+        return p * p * p + 1.0
+
+    @staticmethod
+    def in_out_cubic(progress):
+        '''.. image:: images/anim_in_out_cubic.png
+        '''
+        p = progress * 2
+        if p < 1:
+            return 0.5 * p * p * p
+        p -= 2
+        return 0.5 * (p * p * p + 2.0)
+
+    @staticmethod
+    def in_quart(progress):
+        '''.. image:: images/anim_in_quart.png
+        '''
+        return progress * progress * progress * progress
+
+    @staticmethod
+    def out_quart(progress):
+        '''.. image:: images/anim_out_quart.png
+        '''
+        p = progress - 1.0
+        return -1.0 * (p * p * p * p - 1.0)
+
+    @staticmethod
+    def in_out_quart(progress):
+        '''.. image:: images/anim_in_out_quart.png
+        '''
+        p = progress * 2
+        if p < 1:
+            return 0.5 * p * p * p * p
+        p -= 2
+        return -0.5 * (p * p * p * p - 2.0)
+
+    @staticmethod
+    def in_quint(progress):
+        '''.. image:: images/anim_in_quint.png
+        '''
+        return progress * progress * progress * progress * progress
+
+    @staticmethod
+    def out_quint(progress):
+        '''.. image:: images/anim_out_quint.png
+        '''
+        p = progress - 1.0
+        return p * p * p * p * p + 1.0
+
+    @staticmethod
+    def in_out_quint(progress):
+        '''.. image:: images/anim_in_out_quint.png
+        '''
+        p = progress * 2
+        if p < 1:
+            return 0.5 * p * p * p * p * p
+        p -= 2.0
+        return 0.5 * (p * p * p * p * p + 2.0)
+
+    @staticmethod
+    def in_sine(progress):
+        '''.. image:: images/anim_in_sine.png
+        '''
+        return -1.0 * cos(progress * (pi / 2.0)) + 1.0
+
+    @staticmethod
+    def out_sine(progress):
+        '''.. image:: images/anim_out_sine.png
+        '''
+        return sin(progress * (pi / 2.0))
+
+    @staticmethod
+    def in_out_sine(progress):
+        '''.. image:: images/anim_in_out_sine.png
+        '''
+        return -0.5 * (cos(pi * progress) - 1.0)
+
+    @staticmethod
+    def in_expo(progress):
+        '''.. image:: images/anim_in_expo.png
+        '''
+        if progress == 0:
+            return 0.0
+        return pow(2, 10 * (progress - 1.0))
+
+    @staticmethod
+    def out_expo(progress):
+        '''.. image:: images/anim_out_expo.png
+        '''
+        if progress == 1.0:
+            return 1.0
+        return -pow(2, -10 * progress) + 1.0
+
+    @staticmethod
+    def in_out_expo(progress):
+        '''.. image:: images/anim_in_out_expo.png
+        '''
+        if progress == 0:
+            return 0.0
+        if progress == 1.:
+            return 1.0
+        p = progress * 2
+        if p < 1:
+            return 0.5 * pow(2, 10 * (p - 1.0))
+        p -= 1.0
+        return 0.5 * (-pow(2, -10 * p) + 2.0)
+
+    @staticmethod
+    def in_circ(progress):
+        '''.. image:: images/anim_in_circ.png
+        '''
+        return -1.0 * (sqrt(1.0 - progress * progress) - 1.0)
+
+    @staticmethod
+    def out_circ(progress):
+        '''.. image:: images/anim_out_circ.png
+        '''
+        p = progress - 1.0
+        return sqrt(1.0 - p * p)
+
+    @staticmethod
+    def in_out_circ(progress):
+        '''.. image:: images/anim_in_out_circ.png
+        '''
+        p = progress * 2
+        if p < 1:
+            return -0.5 * (sqrt(1.0 - p * p) - 1.0)
+        p -= 2.0
+        return 0.5 * (sqrt(1.0 - p * p) + 1.0)
+
+    @staticmethod
+    def in_elastic(progress):
+        '''.. image:: images/anim_in_elastic.png
+        '''
+        p = .3
+        s = p / 4.0
+        q = progress
+        if q == 1:
+            return 1.0
+        q -= 1.0
+        return -(pow(2, 10 * q) * sin((q - s) * (2 * pi) / p))
+
+    @staticmethod
+    def out_elastic(progress):
+        '''.. image:: images/anim_out_elastic.png
+        '''
+        p = .3
+        s = p / 4.0
+        q = progress
+        if q == 1:
+            return 1.0
+        return pow(2, -10 * q) * sin((q - s) * (2 * pi) / p) + 1.0
+
+    @staticmethod
+    def in_out_elastic(progress):
+        '''.. image:: images/anim_in_out_elastic.png
+        '''
+        p = .3 * 1.5
+        s = p / 4.0
+        q = progress * 2
+        if q == 2:
+            return 1.0
+        if q < 1:
+            q -= 1.0
+            return -.5 * (pow(2, 10 * q) * sin((q - s) * (2.0 * pi) / p))
+        else:
+            q -= 1.0
+            return pow(2, -10 * q) * sin((q - s) * (2.0 * pi) / p) * .5 + 1.0
+
+    @staticmethod
+    def in_back(progress):
+        '''.. image:: images/anim_in_back.png
+        '''
+        return progress * progress * ((1.70158 + 1.0) * progress - 1.70158)
+
+    @staticmethod
+    def out_back(progress):
+        '''.. image:: images/anim_out_back.png
+        '''
+        p = progress - 1.0
+        return p * p * ((1.70158 + 1) * p + 1.70158) + 1.0
+
+    @staticmethod
+    def in_out_back(progress):
+        '''.. image:: images/anim_in_out_back.png
+        '''
+        p = progress * 2.
+        s = 1.70158 * 1.525
+        if p < 1:
+            return 0.5 * (p * p * ((s + 1.0) * p - s))
+        p -= 2.0
+        return 0.5 * (p * p * ((s + 1.0) * p + s) + 2.0)
+
+    @staticmethod
+    def _out_bounce_internal(t, d):
+        p = t / d
+        if p < (1.0 / 2.75):
+            return 7.5625 * p * p
+        elif p < (2.0 / 2.75):
+            p -= (1.5 / 2.75)
+            return 7.5625 * p * p + .75
+        elif p < (2.5 / 2.75):
+            p -= (2.25 / 2.75)
+            return 7.5625 * p * p + .9375
+        else:
+            p -= (2.625 / 2.75)
+            return 7.5625 * p * p + .984375
+
+    @staticmethod
+    def _in_bounce_internal(t, d):
+        return 1.0 - AnimationTransition._out_bounce_internal(d - t, d)
+
+    @staticmethod
+    def in_bounce(progress):
+        '''.. image:: images/anim_in_bounce.png
+        '''
+        return AnimationTransition._in_bounce_internal(progress, 1.)
+
+    @staticmethod
+    def out_bounce(progress):
+        '''.. image:: images/anim_out_bounce.png
+        '''
+        return AnimationTransition._out_bounce_internal(progress, 1.)
+
+    @staticmethod
+    def in_out_bounce(progress):
+        '''.. image:: images/anim_in_out_bounce.png
+        '''
+        p = progress * 2.
+        if p < 1.:
+            return AnimationTransition._in_bounce_internal(p, 1.) * .5
+        return AnimationTransition._out_bounce_internal(p - 1., 1.) * .5 + .5
diff --git a/kivy/app.py b/kivy/app.py
new file mode 100644
index 0000000..c571b1b
--- /dev/null
+++ b/kivy/app.py
@@ -0,0 +1,1191 @@
+'''
+Application
+===========
+
+The :class:`App` class is the base for creating Kivy applications.
+Think of it as your main entry point into the Kivy run loop. In most
+cases, you subclass this class and make your own app. You create an
+instance of your specific app class and then, when you are ready to
+start the application's life cycle, you call your instance's
+:meth:`App.run` method.
+
+
+Creating an Application
+-----------------------
+
+Method using build() override
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To initialize your app with a widget tree, override the :meth:`~App.build`
+method in your app class and return the widget tree you constructed.
+
+Here's an example of a very simple application that just shows a button:
+
+.. include:: ../../examples/application/app_with_build.py
+   :literal:
+
+The file is also available in the examples folder at
+:file:`kivy/examples/application/app_with_build.py`.
+
+Here, no widget tree was constructed (or if you will, a tree with only
+the root node).
+
+
+Method using kv file
+~~~~~~~~~~~~~~~~~~~~
+
+You can also use the :doc:`api-kivy.lang` for creating applications. The
+.kv can contain rules and root widget definitions at the same time. Here
+is the same example as the Button one in a kv file.
+
+Contents of 'test.kv':
+
+.. include:: ../../examples/application/test.kv
+   :literal:
+
+Contents of 'main.py':
+
+.. include:: ../../examples/application/app_with_kv.py
+   :literal:
+
+See :file:`kivy/examples/application/app_with_kv.py`.
+
+The relationship between main.py and test.kv is explained in
+:meth:`App.load_kv`.
+
+.. _Application configuration:
+
+Application configuration
+-------------------------
+
+Use the configuration file
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Your application might need its own configuration file. The
+:class:`App` class handles 'ini' files automatically if you add
+the section key-value pair to the :meth:`App.build_config` method using the
+`config` parameter (an instance of :class:`~kivy.config.ConfigParser`)::
+
+    class TestApp(App):
+        def build_config(self, config):
+            config.setdefaults('section1', {
+                'key1': 'value1',
+                'key2': '42'
+            })
+
+As soon as you add one section to the config, a file is created on the
+disk (see :attr:`~App.get_application_config` for its location) and
+named based your class name. "TestApp" will give a config file named
+"test.ini" with the content::
+
+    [section1]
+    key1 = value1
+    key2 = 42
+
+The "test.ini" will be automatically loaded at runtime and you can access the
+configuration in your :meth:`App.build` method::
+
+    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')))
+
+Create a settings panel
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Your application can have a settings panel to let your user configure some of
+your config tokens. Here is an example done in the KinectViewer example
+(available in the examples directory):
+
+    .. image:: images/app-settings.jpg
+        :align: center
+
+You can add your own panels of settings by extending
+the :meth:`App.build_settings` method.
+Check the :class:`~kivy.uix.settings.Settings` about how to create a panel,
+because you need a JSON file / data first.
+
+Let's take as an example the previous snippet of TestApp with custom
+config. We could create a JSON like this::
+
+    [
+        { "type": "title",
+          "title": "Test application" },
+
+        { "type": "options",
+          "title": "My first key",
+          "desc": "Description of my first key",
+          "section": "section1",
+          "key": "key1",
+          "options": ["value1", "value2", "another value"] },
+
+        { "type": "numeric",
+          "title": "My second key",
+          "desc": "Description of my second key",
+          "section": "section1",
+          "key": "key2" }
+    ]
+
+Then, we can create a panel using this JSON to automatically create all the
+options and link them to our :attr:`App.config` ConfigParser instance::
+
+    class TestApp(App):
+        # ...
+        def build_settings(self, settings):
+            jsondata = """... put the json data here ..."""
+            settings.add_json_panel('Test application',
+                self.config, data=jsondata)
+
+That's all! Now you can press F1 (default keystroke) to toggle the
+settings panel or press the "settings" key on your android device. You
+can manually call :meth:`App.open_settings` and
+:meth:`App.close_settings` if you want to handle this manually. Every
+change in the panel is automatically saved in the config file.
+
+You can also use :meth:`App.build_settings` to modify properties of
+the settings panel. For instance, the default panel has a sidebar for
+switching between json panels whose width defaults to 200dp. If you'd
+prefer this to be narrower, you could add::
+
+    settings.interface.menu.width = dp(100)
+
+to your :meth:`build_settings` method.
+
+You might want to know when a config value has been changed by the
+user in order to adapt or reload your UI. You can then overload the
+:meth:`on_config_change` method::
+
+    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('Our key1 has been changed to', value)
+                elif token == ('section1', 'key2'):
+                    print('Our key2 has been changed to', value)
+
+The Kivy configuration panel is added by default to the settings
+instance. If you don't want this panel, you can declare your Application as
+follows::
+
+    class TestApp(App):
+        use_kivy_settings = False
+        # ...
+
+This only removes the Kivy panel but does not stop the settings instance
+from appearing. If you want to prevent the settings instance from appearing
+altogether, you can do this::
+
+    class TestApp(App):
+        def open_settings(self, *largs):
+            pass
+
+.. versionadded:: 1.0.7
+
+Profiling with on_start and on_stop
+-----------------------------------
+
+It is often useful to profile python code in order to discover locations to
+optimise. The standard library profilers
+(http://docs.python.org/2/library/profile.html) provides multiple options for
+profiling code. For profiling the entire program, the natural
+approaches of using profile as a module or profile's run method does not work
+with Kivy. It is however, possible to use :meth:`App.on_start` and
+:meth:`App.on_stop` methods::
+
+    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')
+
+This will create a file called `myapp.profile` when you exit your app.
+
+Customising layout
+------------------
+
+You can choose different settings widget layouts by setting
+:attr:`App.settings_cls`. By default, this is a
+:class:`~kivy.uix.settings.Settings` class which provides the pictured
+sidebar layout, but you could set it to any of the other layouts
+provided in :mod:`kivy.uix.settings` or create your own. See the
+module documentation for :mod:`kivy.uix.settings` for more
+information.
+
+You can customise how the settings panel is displayed by
+overriding :meth:`App.display_settings` which is called before
+displaying the settings panel on the screen. By default, it
+simply draws the panel on top of the window, but you could modify it
+to (for instance) show the settings in a
+:class:`~kivy.uix.popup.Popup` or add it to your app's
+:class:`~kivy.uix.screenmanager.ScreenManager` if you are using
+one. If you do so, you should also modify :meth:`App.close_settings`
+to exit the panel appropriately. For instance, to have the settings
+panel appear in a popup you can do::
+
+    def display_settings(self, settings):
+        try:
+            p = self.settings_popup
+        except AttributeError:
+            self.settings_popup = Popup(content=settings,
+                                        title='Settings',
+                                        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 # Settings popup doesn't exist
+
+Finally, if you want to replace the current settings panel widget, you
+can remove the internal references to it using
+:meth:`App.destroy_settings`. If you have modified
+:meth:`App.display_settings`, you should be careful to detect if the
+settings panel has been replaced.
+
+Pause mode
+----------
+
+.. versionadded:: 1.1.0
+
+On tablets and phones, the user can switch at any moment to another
+application. By default, your application will close and the
+:meth:`App.on_stop` event will be fired.
+
+If you support Pause mode, when switching to another application, your
+application will wait indefinitely until the user
+switches back to your application. There is an issue with OpenGL on Android
+devices: it is not guaranteed that the OpenGL ES Context will be restored when
+your app resumes. The mechanism for restoring all the OpenGL data is not yet
+implemented in Kivy.
+
+The currently implemented Pause mechanism is:
+
+    #. Kivy checks every frame if Pause mode is activated by the Operating
+       System due to the user switching to another application, a phone
+       shutdown or any other reason.
+    #. :meth:`App.on_pause` is called:
+    #. If False is returned, then :meth:`App.on_stop` is called.
+    #. If True is returned (default case), the application will sleep until
+       the OS resumes our App.
+    #. When the app is resumed, :meth:`App.on_resume` is called.
+    #. If our app memory has been reclaimed by the OS, then nothing will be
+       called.
+
+Here is a simple example of how on_pause() should be used::
+
+   class TestApp(App):
+
+      def on_pause(self):
+         # Here you can save data if needed
+         return True
+
+      def on_resume(self):
+         # Here you can check if any data needs replacing (usually nothing)
+         pass
+
+.. warning::
+
+    Both `on_pause` and `on_stop` must save important data because after
+    `on_pause` is called, `on_resume` may not be called at all.
+
+Asynchronous app
+----------------
+
+In addition to running an app normally,
+Kivy can be run within an async event loop such as provided by the standard
+library asyncio package or the trio package (highly recommended).
+
+Background
+~~~~~~~~~~
+
+Normally, when a Kivy app is run, it blocks the thread that runs it until the
+app exits. Internally, at each clock iteration it executes all the app
+callbacks, handles graphics and input, and idles by sleeping for any remaining
+time.
+
+To be able to run asynchronously, the Kivy app may not sleep, but instead must
+release control of the running context to the asynchronous event loop running
+the Kivy app. We do this when idling by calling the appropriate functions of
+the async package being used instead of sleeping.
+
+Async configuration
+~~~~~~~~~~~~~~~~~~~
+
+To run a Kivy app asynchronously, either the :func:`async_runTouchApp` or
+:meth:`App.async_run` coroutine must be scheduled to run in the event loop of
+the async library being used.
+
+The environmental variable ``KIVY_EVENTLOOP`` or the ``async_lib`` parameter in
+:func:`async_runTouchApp` and :meth:`App.async_run` set the async
+library that Kivy uses internally when the app is run with
+:func:`async_runTouchApp` and :meth:`App.async_run`. It can be set to one of
+`"asyncio"` when the standard library `asyncio` is used, or `"trio"` if the
+trio library is used. If the environment variable is not set and ``async_lib``
+is not provided, the stdlib ``asyncio`` is used.
+
+:meth:`~kivy.clock.ClockBaseBehavior.init_async_lib` can also be directly
+called to set the async library to use, but it may only be called before the
+app has begun running with :func:`async_runTouchApp` or :meth:`App.async_run`.
+
+To run the app asynchronously, one schedules :func:`async_runTouchApp`
+or :meth:`App.async_run` to run within the given library's async event loop as
+in the examples shown below. Kivy is then treated as just another coroutine
+that the given library runs in its event loop. Internally, Kivy will use the
+specified async library's API, so ``KIVY_EVENTLOOP`` or ``async_lib`` must
+match the async library that is running Kivy.
+
+
+For a fuller basic and more advanced examples, see the demo apps in
+``examples/async``.
+
+Asyncio example
+~~~~~~~~~~~~~--
+
+.. code-block:: python
+
+    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='Hello, World!'), async_lib='asyncio'))
+    loop.close()
+
+Trio example
+~~~~~~~~~~--
+
+.. code-block:: python
+
+    import trio
+
+    from kivy.app import async_runTouchApp
+    from kivy.uix.label import Label
+
+    from functools import partial
+
+    # use functools.partial() to pass keyword arguments:
+    async_runTouchApp_func = partial(async_runTouchApp, async_lib='trio')
+
+    trio.run(async_runTouchApp_func, Label(text='Hello, World!'))
+
+Interacting with Kivy app from other coroutines
+-----------------------------------------------
+
+It is fully safe to interact with any kivy object from other coroutines
+running within the same async event loop. This is because they are all running
+from the same thread and the other coroutines are only executed when Kivy
+is idling.
+
+Similarly, the kivy callbacks may safely interact with objects from other
+coroutines running in the same event loop. Normal single threaded rules apply
+to both case.
+
+.. versionadded:: 2.0.0
+
+'''
+
+__all__ = ('App', 'runTouchApp', 'async_runTouchApp', 'stopTouchApp')
+
+import os
+from inspect import getfile
+from os.path import dirname, join, exists, sep, expanduser, isfile
+from kivy.config import ConfigParser
+from kivy.base import runTouchApp, async_runTouchApp, stopTouchApp
+from kivy.compat import string_types
+from kivy.factory import Factory
+from kivy.logger import Logger
+from kivy.event import EventDispatcher
+from kivy.lang import Builder
+from kivy.resources import resource_find
+from kivy.utils import platform
+from kivy.uix.widget import Widget
+from kivy.properties import ObjectProperty, StringProperty
+from kivy.setupconfig import USE_SDL2
+
+
+class App(EventDispatcher):
+    ''' Application class, see module documentation for more information.
+
+    :Events:
+        `on_start`:
+            Fired when the application is being started (before the
+            :func:`~kivy.base.runTouchApp` call.
+        `on_stop`:
+            Fired when the application stops.
+        `on_pause`:
+            Fired when the application is paused by the OS.
+        `on_resume`:
+            Fired when the application is resumed from pause by the OS. Beware:
+            you have no guarantee that this event will be fired after the
+            `on_pause` event has been called.
+
+    .. versionchanged:: 1.7.0
+        Parameter `kv_file` added.
+
+    .. versionchanged:: 1.8.0
+        Parameters `kv_file` and `kv_directory` are now properties of App.
+    '''
+
+    title = StringProperty(None)
+    '''
+    Title of your application. You can set this as follows::
+
+        class MyApp(App):
+            def build(self):
+                self.title = 'Hello world'
+
+    .. versionadded:: 1.0.5
+
+    .. versionchanged:: 1.8.0
+        `title` is now a :class:`~kivy.properties.StringProperty`. Don't
+        set the title in the class as previously stated in the documentation.
+
+    .. note::
+
+        For Kivy < 1.8.0, you can set this as follows::
+
+            class MyApp(App):
+                title = 'Custom title'
+
+        If you want to dynamically change the title, you can do::
+
+            from kivy.base import EventLoop
+            EventLoop.window.title = 'New title'
+
+    '''
+
+    icon = StringProperty(None)
+    '''Icon of your application.
+    The icon can be located in the same directory as your main file. You can
+    set this as follows::
+
+        class MyApp(App):
+            def build(self):
+                self.icon = 'myicon.png'
+
+    .. versionadded:: 1.0.5
+
+    .. versionchanged:: 1.8.0
+        `icon` is now a :class:`~kivy.properties.StringProperty`. Don't set the
+        icon in the class as previously stated in the documentation.
+
+    .. note::
+
+        For Kivy prior to 1.8.0, you need to set this as follows::
+
+            class MyApp(App):
+                icon = 'customicon.png'
+
+        Recommended 256x256 or 1024x1024? for GNU/Linux and Mac OSX
+        32x32 for Windows7 or less. <= 256x256 for windows 8
+        256x256 does work (on Windows 8 at least), but is scaled
+        down and doesn't look as good as a 32x32 icon.
+    '''
+
+    use_kivy_settings = True
+    '''.. versionadded:: 1.0.7
+
+    If True, the application settings will also include the Kivy settings. If
+    you don't want the user to change any kivy settings from your settings UI,
+    change this to False.
+    '''
+
+    settings_cls = ObjectProperty(None)
+    '''.. versionadded:: 1.8.0
+
+    The class used to construct the settings panel and
+    the instance passed to :meth:`build_config`. You should
+    use either :class:`~kivy.uix.settings.Settings` or one of the provided
+    subclasses with different layouts
+    (:class:`~kivy.uix.settings.SettingsWithSidebar`,
+    :class:`~kivy.uix.settings.SettingsWithSpinner`,
+    :class:`~kivy.uix.settings.SettingsWithTabbedPanel`,
+    :class:`~kivy.uix.settings.SettingsWithNoMenu`). You can also create your
+    own Settings subclass. See the documentation
+    of :mod:`~kivy.uix.settings.Settings` for more information.
+
+    :attr:`~App.settings_cls` is an :class:`~kivy.properties.ObjectProperty`
+    and defaults to :class:`~kivy.uix.settings.SettingsWithSpinner` which
+    displays settings panels with a spinner to switch between them. If you set
+    a string, the :class:`~kivy.factory.Factory` will be used to resolve the
+    class.
+
+    '''
+
+    kv_directory = StringProperty(None)
+    '''Path of the directory where application kv is stored, defaults to None
+
+    .. versionadded:: 1.8.0
+
+    If a kv_directory is set, it will be used to get the initial kv file. By
+    default, the file is assumed to be in the same directory as the current App
+    definition file.
+    '''
+
+    kv_file = StringProperty(None)
+    '''Filename of the Kv file to load, defaults to None.
+
+    .. versionadded:: 1.8.0
+
+    If a kv_file is set, it will be loaded when the application starts. The
+    loading of the "default" kv file will be prevented.
+    '''
+
+    # Return the current running App instance
+    _running_app = None
+
+    __events__ = ('on_start', 'on_stop', 'on_pause', 'on_resume',
+                  'on_config_change', )
+
+    # Stored so that we only need to determine this once
+    _user_data_dir = ""
+
+    def __init__(self, **kwargs):
+        App._running_app = self
+        self._app_directory = None
+        self._app_name = None
+        self._app_settings = None
+        self._app_window = None
+        super(App, self).__init__(**kwargs)
+        self.built = False
+
+        #: Options passed to the __init__ of the App
+        self.options = kwargs
+
+        #: Returns an instance of the :class:`~kivy.config.ConfigParser` for
+        #: the application configuration. You can use this to query some config
+        #: tokens in the :meth:`build` method.
+        self.config = None
+
+        #: The *root* widget returned by the :meth:`build` method or by the
+        #: :meth:`load_kv` method if the kv file contains a root widget.
+        self.root = None
+
+    def build(self):
+        '''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.
+
+        :return:
+            None or a root :class:`~kivy.uix.widget.Widget` instance
+            if no self.root exists.'''
+
+        if not self.root:
+            return Widget()
+
+    def build_config(self, config):
+        '''.. versionadded:: 1.0.7
+
+        This method is called before the application is initialized to
+        construct your :class:`~kivy.config.ConfigParser` object. This
+        is where you can put any default section / key / value for your
+        config. If anything is set, the configuration will be
+        automatically saved in the file returned by
+        :meth:`get_application_config`.
+
+        :Parameters:
+            `config`: :class:`~kivy.config.ConfigParser`
+                Use this to add default section / key / value items
+
+        '''
+
+    def build_settings(self, settings):
+        '''.. versionadded:: 1.0.7
+
+        This method is called when the user (or you) want to show the
+        application settings. It is called once when the settings panel
+        is first opened, after which the panel is cached. It may be
+        called again if the cached settings panel is removed by
+        :meth:`destroy_settings`.
+
+        You can use this method to add settings panels and to
+        customise the settings widget e.g. by changing the sidebar
+        width. See the module documentation for full details.
+
+        :Parameters:
+            `settings`: :class:`~kivy.uix.settings.Settings`
+                Settings instance for adding panels
+
+        '''
+
+    def load_kv(self, filename=None):
+        '''This method is invoked the first time the app is being run if no
+        widget tree has been constructed before for this app.
+        This method then looks for a matching kv file in the same directory as
+        the file that contains the application class.
+
+        For example, say you have a file named main.py that contains::
+
+            class ShowcaseApp(App):
+                pass
+
+        This method will search for a file named `showcase.kv` in
+        the directory that contains main.py. The name of the kv file has to be
+        the lowercase name of the class, without the 'App' postfix at the end
+        if it exists.
+
+        You can define rules and a root widget in your kv file::
+
+            <ClassName>: # this is a rule
+                ...
+
+            ClassName: # this is a root widget
+                ...
+
+        There must be only one root widget. See the :doc:`api-kivy.lang`
+        documentation for more information on how to create kv files. If your
+        kv file contains a root widget, it will be used as self.root, the root
+        widget for the application.
+
+        .. note::
+
+            This function is called from :meth:`run`, therefore, any widget
+            whose styling is defined in this kv file and is created before
+            :meth:`run` is called (e.g. in `__init__`), won't have its styling
+            applied. Note that :meth:`build` is called after :attr:`load_kv`
+            has been called.
+        '''
+        # Detect filename automatically if it was not specified.
+        if filename:
+            filename = resource_find(filename)
+        else:
+            try:
+                default_kv_directory = dirname(getfile(self.__class__))
+                if default_kv_directory == '':
+                    default_kv_directory = '.'
+            except TypeError:
+                # if it's a builtin module.. use the current dir.
+                default_kv_directory = '.'
+
+            kv_directory = self.kv_directory or default_kv_directory
+            clsname = self.__class__.__name__.lower()
+            if (clsname.endswith('app') and
+                    not isfile(join(kv_directory, '%s.kv' % clsname))):
+                clsname = clsname[:-3]
+            filename = join(kv_directory, '%s.kv' % clsname)
+
+        # Load KV file
+        Logger.debug('App: Loading kv <{0}>'.format(filename))
+        rfilename = resource_find(filename)
+        if rfilename is None or not exists(rfilename):
+            Logger.debug('App: kv <%s> not found' % filename)
+            return False
+        root = Builder.load_file(rfilename)
+        if root:
+            self.root = root
+        return True
+
+    def get_application_name(self):
+        '''Return the name of the application.
+        '''
+        if self.title is not None:
+            return self.title
+        clsname = self.__class__.__name__
+        if clsname.endswith('App'):
+            clsname = clsname[:-3]
+        return clsname
+
+    def get_application_icon(self):
+        '''Return the icon of the application.
+        '''
+        if not resource_find(self.icon):
+            return ''
+        else:
+            return resource_find(self.icon)
+
+    def get_application_config(self, defaultpath='%(appdir)s/%(appname)s.ini'):
+        '''
+        Return the filename of your application configuration. Depending
+        on the platform, the application file will be stored in
+        different locations:
+
+            - on iOS: <appdir>/Documents/.<appname>.ini
+            - on Android: <user_data_dir>/.<appname>.ini
+            - otherwise: <appdir>/<appname>.ini
+
+        When you are distributing your application on Desktops, please
+        note that if the application is meant to be installed
+        system-wide, the user might not have write-access to the
+        application directory. If you want to store user settings, you
+        should overload this method and change the default behavior to
+        save the configuration file in the user directory. ::
+
+            class TestApp(App):
+                def get_application_config(self):
+                    return super(TestApp, self).get_application_config(
+                        '~/.%(appname)s.ini')
+
+        Some notes:
+
+        - The tilda '~' will be expanded to the user directory.
+        - %(appdir)s will be replaced with the application :attr:`directory`
+        - %(appname)s will be replaced with the application :attr:`name`
+
+        .. versionadded:: 1.0.7
+
+        .. versionchanged:: 1.4.0
+            Customized the defaultpath for iOS and Android platforms. Added a
+            defaultpath parameter for desktop OS's (not applicable to iOS
+            and Android.)
+
+        .. versionchanged:: 1.11.0
+            Changed the Android version to make use of the
+            :attr:`~App.user_data_dir` and added a missing dot to the iOS
+            config file name.
+        '''
+
+        if platform == 'android':
+            return join(self.user_data_dir, '.{0}.ini'.format(self.name))
+        elif platform == 'ios':
+            defaultpath = '~/Documents/.%(appname)s.ini'
+        elif platform == 'win':
+            defaultpath = defaultpath.replace('/', sep)
+        return expanduser(defaultpath) % {
+            'appname': self.name, 'appdir': self.directory}
+
+    @property
+    def root_window(self):
+        '''.. versionadded:: 1.9.0
+
+        Returns the root window instance used by :meth:`run`.
+        '''
+        return self._app_window
+
+    def load_config(self):
+        '''(internal) This function is used for returning a ConfigParser with
+        the application configuration. It's doing 3 things:
+
+            #. Creating an instance of a ConfigParser
+            #. Loading the default configuration by calling
+               :meth:`build_config`, then
+            #. If it exists, it loads the application configuration file,
+               otherwise it creates one.
+
+        :return:
+            :class:`~kivy.config.ConfigParser` instance
+        '''
+        try:
+            config = ConfigParser.get_configparser('app')
+        except KeyError:
+            config = None
+        if config is None:
+            config = ConfigParser(name='app')
+        self.config = config
+        self.build_config(config)
+        # if no sections are created, that's mean the user don't have
+        # configuration.
+        if len(config.sections()) == 0:
+            return
+        # ok, the user have some sections, read the default file if exist
+        # or write it !
+        filename = self.get_application_config()
+        if filename is None:
+            return config
+        Logger.debug('App: Loading configuration <{0}>'.format(filename))
+        if exists(filename):
+            try:
+                config.read(filename)
+            except:
+                Logger.error('App: Corrupted config file, ignored.')
+                config.name = ''
+                try:
+                    config = ConfigParser.get_configparser('app')
+                except KeyError:
+                    config = None
+                if config is None:
+                    config = ConfigParser(name='app')
+                self.config = config
+                self.build_config(config)
+                pass
+        else:
+            Logger.debug('App: First configuration, create <{0}>'.format(
+                filename))
+            config.filename = filename
+            config.write()
+        return config
+
+    @property
+    def directory(self):
+        '''.. versionadded:: 1.0.7
+
+        Return the directory where the application lives.
+        '''
+        if self._app_directory is None:
+            try:
+                self._app_directory = dirname(getfile(self.__class__))
+                if self._app_directory == '':
+                    self._app_directory = '.'
+            except TypeError:
+                # if it's a builtin module.. use the current dir.
+                self._app_directory = '.'
+        return self._app_directory
+
+    def _get_user_data_dir(self):
+        # Determine and return the user_data_dir.
+        data_dir = ""
+        if platform == 'ios':
+            data_dir = expanduser(join('~/Documents', self.name))
+        elif platform == 'android':
+            from jnius import autoclass, cast
+            PythonActivity = autoclass('org.kivy.android.PythonActivity')
+            context = cast('android.content.Context', PythonActivity.mActivity)
+            file_p = cast('java.io.File', context.getFilesDir())
+            data_dir = file_p.getAbsolutePath()
+        elif platform == 'win':
+            data_dir = os.path.join(os.environ['APPDATA'], self.name)
+        elif platform == 'macosx':
+            data_dir = '~/Library/Application Support/{}'.format(self.name)
+            data_dir = expanduser(data_dir)
+        else:  # _platform == 'linux' or anything else...:
+            data_dir = os.environ.get('XDG_CONFIG_HOME', '~/.config')
+            data_dir = expanduser(join(data_dir, self.name))
+        if not exists(data_dir):
+            os.mkdir(data_dir)
+        return data_dir
+
+    @property
+    def user_data_dir(self):
+        '''
+        .. versionadded:: 1.7.0
+
+        Returns the path to the directory in the users file system which the
+        application can use to store additional data.
+
+        Different platforms have different conventions with regards to where
+        the user can store data such as preferences, saved games and settings.
+        This function implements these conventions. The <app_name> directory
+        is created when the property is called, unless it already exists.
+
+        On iOS, `~/Documents/<app_name>` is returned (which is inside the
+        app's sandbox).
+
+        On Windows, `%APPDATA%/<app_name>` is returned.
+
+        On OS X, `~/Library/Application Support/<app_name>` is returned.
+
+        On Linux, `$XDG_CONFIG_HOME/<app_name>` is returned.
+
+        On Android, `Context.GetFilesDir
+        <https://developer.android.com/reference/android/content/\
+Context.html#getFilesDir()>`_ is returned.
+
+        .. versionchanged:: 1.11.0
+
+            On Android, this function previously returned
+            `/sdcard/<app_name>`. This folder became read-only by default
+            in Android API 26 and the user_data_dir has therefore been moved
+            to a writeable location.
+
+        '''
+        if self._user_data_dir == "":
+            self._user_data_dir = self._get_user_data_dir()
+        return self._user_data_dir
+
+    @property
+    def name(self):
+        '''.. versionadded:: 1.0.7
+
+        Return the name of the application based on the class name.
+        '''
+        if self._app_name is None:
+            clsname = self.__class__.__name__
+            if clsname.endswith('App'):
+                clsname = clsname[:-3]
+            self._app_name = clsname.lower()
+        return self._app_name
+
+    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')
+
+    def run(self):
+        '''Launches the app in standalone mode.
+        '''
+        self._run_prepare()
+        runTouchApp()
+        self.stop()
+
+    async def async_run(self, async_lib=None):
+        '''Identical to :meth:`run`, but is a coroutine and can be
+        scheduled in a running async event loop.
+
+        See :mod:`kivy.app` for example usage.
+
+        .. versionadded:: 2.0.0
+        '''
+        self._run_prepare()
+        await async_runTouchApp(async_lib=async_lib)
+        self.stop()
+
+    def stop(self, *largs):
+        '''Stop the application.
+
+        If you use this method, the whole application will stop by issuing
+        a call to :func:`~kivy.base.stopTouchApp`.
+        '''
+        self.dispatch('on_stop')
+        stopTouchApp()
+
+        # Clear the window children
+        if self._app_window:
+            for child in self._app_window.children:
+                self._app_window.remove_widget(child)
+        App._running_app = None
+
+    def on_start(self):
+        '''Event handler for the `on_start` event which is fired after
+        initialization (after build() has been called) but before the
+        application has started running.
+        '''
+        pass
+
+    def on_stop(self):
+        '''Event handler for the `on_stop` event which is fired when the
+        application has finished running (i.e. the window is about to be
+        closed).
+        '''
+        pass
+
+    def on_pause(self):
+        '''Event handler called when Pause mode is requested. You should
+        return True if your app can go into Pause mode, otherwise
+        return False and your application will be stopped.
+
+        You cannot control when the application is going to go into this mode.
+        It's determined by the Operating System and mostly used for mobile
+        devices (android/ios) and for resizing.
+
+        The default return value is True.
+
+        .. versionadded:: 1.1.0
+        .. versionchanged:: 1.10.0
+            The default return value is now True.
+        '''
+        return True
+
+    def on_resume(self):
+        '''Event handler called when your application is resuming from
+        the Pause mode.
+
+        .. versionadded:: 1.1.0
+
+        .. warning::
+
+            When resuming, the OpenGL Context might have been damaged / freed.
+            This is where you can reconstruct some of your OpenGL state
+            e.g. FBO content.
+        '''
+        pass
+
+    @staticmethod
+    def get_running_app():
+        '''Return the currently running application instance.
+
+        .. versionadded:: 1.1.0
+        '''
+        return App._running_app
+
+    def on_config_change(self, config, section, key, value):
+        '''Event handler fired when a configuration token has been changed by
+        the settings page.
+
+        .. versionchanged:: 1.10.1
+           Added corresponding ``on_config_change`` event.
+        '''
+        pass
+
+    def open_settings(self, *largs):
+        '''Open the application settings panel. It will be created the very
+        first time, or recreated if the previously cached panel has been
+        removed by :meth:`destroy_settings`. The settings panel will be
+        displayed with the
+        :meth:`display_settings` method, which by default adds the
+        settings panel to the Window attached to your application. You
+        should override that method if you want to display the
+        settings panel differently.
+
+        :return:
+            True if the settings has been opened.
+
+        '''
+        if self._app_settings is None:
+            self._app_settings = self.create_settings()
+        displayed = self.display_settings(self._app_settings)
+        if displayed:
+            return True
+        return False
+
+    def display_settings(self, settings):
+        '''.. versionadded:: 1.8.0
+
+        Display the settings panel. By default, the panel is drawn directly
+        on top of the window. You can define other behaviour by overriding
+        this method, such as adding it to a ScreenManager or Popup.
+
+        You should return True if the display is successful, otherwise False.
+
+        :Parameters:
+            `settings`: :class:`~kivy.uix.settings.Settings`
+                You can modify this object in order to modify the settings
+                display.
+
+        '''
+        win = self._app_window
+        if not win:
+            raise Exception('No windows are set on the application, you cannot'
+                            ' open settings yet.')
+        if settings not in win.children:
+            win.add_widget(settings)
+            return True
+        return False
+
+    def close_settings(self, *largs):
+        '''Close the previously opened settings panel.
+
+        :return:
+            True if the settings has been closed.
+        '''
+        win = self._app_window
+        settings = self._app_settings
+        if win is None or settings is None:
+            return
+        if settings in win.children:
+            win.remove_widget(settings)
+            return True
+        return False
+
+    def create_settings(self):
+        '''Create the settings panel. This method will normally
+        be called only one time per
+        application life-time and the result is cached internally,
+        but it may be called again if the cached panel is removed
+        by :meth:`destroy_settings`.
+
+        By default, it will build a settings panel according to
+        :attr:`settings_cls`, call :meth:`build_settings`, add a Kivy panel if
+        :attr:`use_kivy_settings` is True, and bind to
+        on_close/on_config_change.
+
+        If you want to plug your own way of doing settings, without the Kivy
+        panel or close/config change events, this is the method you want to
+        overload.
+
+        .. versionadded:: 1.8.0
+        '''
+        if self.settings_cls is None:
+            from kivy.uix.settings import SettingsWithSpinner
+            self.settings_cls = SettingsWithSpinner
+        elif isinstance(self.settings_cls, string_types):
+            self.settings_cls = Factory.get(self.settings_cls)
+        s = self.settings_cls()
+        self.build_settings(s)
+        if self.use_kivy_settings:
+            s.add_kivy_panel()
+        s.bind(on_close=self.close_settings,
+               on_config_change=self._on_config_change)
+        return s
+
+    def destroy_settings(self):
+        '''.. versionadded:: 1.8.0
+
+        Dereferences the current settings panel if one
+        exists. This means that when :meth:`App.open_settings` is next
+        run, a new panel will be created and displayed. It doesn't
+        affect any of the contents of the panel, but lets you (for
+        instance) refresh the settings panel layout if you have
+        changed the settings widget in response to a screen size
+        change.
+
+        If you have modified :meth:`~App.open_settings` or
+        :meth:`~App.display_settings`, you should be careful to
+        correctly detect if the previous settings widget has been
+        destroyed.
+
+        '''
+        if self._app_settings is not None:
+            self._app_settings = None
+
+    #
+    # privates
+    #
+
+    def _on_config_change(self, *largs):
+        self.dispatch('on_config_change', *largs[1:])
+
+    def _install_settings_keys(self, window):
+        window.bind(on_keyboard=self._on_keyboard_settings)
+
+    def _on_keyboard_settings(self, window, *largs):
+        key = largs[0]
+        setting_key = 282  # F1
+
+        # android hack, if settings key is pygame K_MENU
+        if platform == 'android' and not USE_SDL2:
+            import pygame
+            setting_key = pygame.K_MENU
+
+        if key == setting_key:
+            # toggle settings panel
+            if not self.open_settings():
+                self.close_settings()
+            return True
+        if key == 27:
+            return self.close_settings()
+
+    def on_title(self, instance, title):
+        if self._app_window:
+            self._app_window.set_title(title)
+
+    def on_icon(self, instance, icon):
+        if self._app_window:
+            self._app_window.set_icon(self.get_application_icon())
diff --git a/kivy/atlas.py b/kivy/atlas.py
new file mode 100644
index 0000000..c893ca3
--- /dev/null
+++ b/kivy/atlas.py
@@ -0,0 +1,456 @@
+'''
+Atlas
+=====
+
+.. versionadded:: 1.1.0
+
+Atlas manages texture atlases: packing multiple textures into
+one. With it, you reduce the number of images loaded and speedup the
+application loading. This module contains both the Atlas class and command line
+processing for creating an atlas from a set of individual PNG files. The
+command line section requires the Pillow library, or the defunct Python Imaging
+Library (PIL), to be installed.
+
+An Atlas is composed of 2 or more files:
+    - a json file (.atlas) that contains the image file names and texture
+      locations of the atlas.
+    - one or multiple image files containing textures referenced by the .atlas
+      file.
+
+Definition of .atlas files
+--------------------------
+
+A file with ``<basename>.atlas`` is a json file formatted like this::
+
+    {
+        "<basename>-<index>.png": {
+            "id1": [ <x>, <y>, <width>, <height> ],
+            "id2": [ <x>, <y>, <width>, <height> ],
+            # ...
+        },
+        # ...
+    }
+
+Example from the Kivy ``data/images/defaulttheme.atlas``::
+
+    {
+        "defaulttheme-0.png": {
+            "progressbar_background": [431, 224, 59, 24],
+            "image-missing": [253, 344, 48, 48],
+            "filechooser_selected": [1, 207, 118, 118],
+            "bubble_btn": [83, 174, 32, 32],
+            # ... and more ...
+        }
+    }
+
+In this example, "defaulttheme-0.png" is a large image, with the pixels in the
+rectangle from (431, 224) to (431 + 59, 224 + 24) usable as
+``atlas://data/images/defaulttheme/progressbar_background`` in
+any image parameter.
+
+How to create an Atlas
+----------------------
+
+.. warning::
+
+    The atlas creation requires the Pillow library (or the defunct Imaging/PIL
+    library). This requirement will be removed in the future when the Kivy core
+    Image is able to support loading, blitting, and saving operations.
+
+You can directly use this module to create atlas files with this command::
+
+    $ python -m kivy.atlas <basename> <size> <list of images...>
+
+
+Let's say you have a list of images that you want to put into an Atlas. The
+directory is named ``images`` with lots of 64x64 png files inside::
+
+    $ ls
+    images
+    $ cd images
+    $ ls
+    bubble.png bubble-red.png button.png button-down.png
+
+You can combine all the png's into one and generate the atlas file with::
+
+    $ python -m kivy.atlas myatlas 256x256 *.png
+    Atlas created at myatlas.atlas
+    1 image has been created
+    $ ls
+    bubble.png bubble-red.png button.png button-down.png myatlas.atlas
+    myatlas-0.png
+
+As you can see, we get 2 new files: ``myatlas.atlas`` and ``myatlas-0.png``.
+``myatlas-0.png`` is a new 256x256 .png composed of all your images. If the
+size you specify is not large enough to fit all of the source images, more
+atlas images will be created as required e.g. ``myatlas-1.png``,
+``myatlas-2.png`` etc.
+
+.. note::
+
+    When using this script, the ids referenced in the atlas are the base names
+    of the images without the extension. So, if you are going to name a file
+    ``../images/button.png``, the id for this image will be ``button``.
+
+    If you need path information included, you should include ``use_path`` as
+    follows::
+
+        $ python -m kivy.atlas -- --use_path myatlas 256 *.png
+
+    In which case the id for ``../images/button.png`` will be ``images_button``
+
+
+How to use an Atlas
+-------------------
+
+Usually, you would specify the images by supplying the path::
+
+    a = Button(background_normal='images/button.png',
+               background_down='images/button_down.png')
+
+In our previous example, we have created the atlas containing both images and
+put them in ``images/myatlas.atlas``. You can use url notation to reference
+them::
+
+    a = Button(background_normal='atlas://images/myatlas/button',
+               background_down='atlas://images/myatlas/button_down')
+
+In other words, the path to the images is replaced by::
+
+    atlas://path/to/myatlas/id
+    # will search for the ``path/to/myatlas.atlas`` and get the image ``id``
+
+.. note::
+
+    In the atlas url, there is no need to add the ``.atlas`` extension. It will
+    be automatically append to the filename.
+
+Manual usage of the Atlas
+-------------------------
+
+::
+
+    >>> from kivy.atlas import Atlas
+    >>> atlas = Atlas('path/to/myatlas.atlas')
+    >>> print(atlas.textures.keys())
+    ['bubble', 'bubble-red', 'button', 'button-down']
+    >>> print(atlas['button'])
+    <kivy.graphics.texture.TextureRegion object at 0x2404d10>
+'''
+
+__all__ = ('Atlas', )
+
+import json
+from os.path import basename, dirname, join, splitext
+from kivy.event import EventDispatcher
+from kivy.logger import Logger
+from kivy.properties import AliasProperty, DictProperty, ListProperty
+import os
+
+
+# late import to prevent recursion
+CoreImage = None
+
+
+class Atlas(EventDispatcher):
+    '''Manage texture atlas. See module documentation for more information.
+    '''
+
+    original_textures = ListProperty([])
+    '''List of original atlas textures (which contain the :attr:`textures`).
+
+    :attr:`original_textures` is a :class:`~kivy.properties.ListProperty` and
+    defaults to [].
+
+    .. versionadded:: 1.9.1
+    '''
+
+    textures = DictProperty({})
+    '''List of available textures within the atlas.
+
+    :attr:`textures` is a :class:`~kivy.properties.DictProperty` and defaults
+    to {}.
+    '''
+
+    def _get_filename(self):
+        return self._filename
+
+    filename = AliasProperty(_get_filename, None)
+    '''Filename of the current Atlas.
+
+    :attr:`filename` is an :class:`~kivy.properties.AliasProperty` and defaults
+    to None.
+    '''
+
+    def __init__(self, filename):
+        self._filename = filename
+        super(Atlas, self).__init__()
+        self._load()
+
+    def __getitem__(self, key):
+        return self.textures[key]
+
+    def _load(self):
+        # late import to prevent recursive import.
+        global CoreImage
+        if CoreImage is None:
+            from kivy.core.image import Image as CoreImage
+
+        # must be a name finished by .atlas ?
+        filename = self._filename
+        assert(filename.endswith('.atlas'))
+        filename = filename.replace('/', os.sep)
+
+        Logger.debug('Atlas: Load <%s>' % filename)
+        with open(filename, 'r') as fd:
+            meta = json.load(fd)
+
+        Logger.debug('Atlas: Need to load %d images' % len(meta))
+        d = dirname(filename)
+        textures = {}
+        for subfilename, ids in meta.items():
+            subfilename = join(d, subfilename)
+            Logger.debug('Atlas: Load <%s>' % subfilename)
+
+            # load the image
+            ci = CoreImage(subfilename)
+            atlas_texture = ci.texture
+            self.original_textures.append(atlas_texture)
+
+            # for all the uid, load the image, get the region, and put
+            # it in our dict.
+            for meta_id, meta_coords in ids.items():
+                x, y, w, h = meta_coords
+                textures[meta_id] = atlas_texture.get_region(*meta_coords)
+
+        self.textures = textures
+
+    @staticmethod
+    def create(outname, filenames, size, padding=2, use_path=False):
+        '''This method can be used to create an atlas manually from a set of
+        images.
+
+        :Parameters:
+            `outname`: str
+                Basename to use for ``.atlas`` creation and ``-<idx>.png``
+                associated images.
+            `filenames`: list
+                List of filenames to put in the atlas.
+            `size`: int or list (width, height)
+                Size of the atlas image. If the size is not large enough to
+                fit all of the source images, more atlas images will created
+                as required.
+            `padding`: int, defaults to 2
+                Padding to put around each image.
+
+                Be careful. If you're using a padding < 2, you might have
+                issues with the borders of the images. Because of the OpenGL
+                linearization, it might use the pixels of the adjacent image.
+
+                If you're using a padding >= 2, we'll automatically generate a
+                "border" of 1px around your image. If you look at
+                the result, don't be scared if the image inside is not
+                exactly the same as yours :).
+
+            `use_path`: bool, defaults to False
+                If True, the relative path of the source png
+                file names will be included in the atlas ids rather
+                that just in the file names. Leading dots and slashes will be
+                excluded and all other slashes in the path will be replaced
+                with underscores. For example, if `use_path` is False
+                (the default) and the file name is
+                ``../data/tiles/green_grass.png``, the id will be
+                ``green_grass``. If `use_path` is True, it will be
+                ``data_tiles_green_grass``.
+
+            .. versionchanged:: 1.8.0
+                Parameter use_path added
+        '''
+        # Thanks to
+        # omnisaurusgames.com/2011/06/texture-atlas-generation-using-python/
+        # for its initial implementation.
+        try:
+            from PIL import Image
+        except ImportError:
+            Logger.critical('Atlas: Imaging/PIL are missing')
+            raise
+
+        if isinstance(size, (tuple, list)):
+            size_w, size_h = list(map(int, size))
+        else:
+            size_w = size_h = int(size)
+
+        # open all of the images
+        ims = list()
+        for f in filenames:
+            fp = open(f, 'rb')
+            im = Image.open(fp)
+            im.load()
+            fp.close()
+            ims.append((f, im))
+
+        # sort by image area
+        ims = sorted(ims, key=lambda im: im[1].size[0] * im[1].size[1],
+                     reverse=True)
+
+        # free boxes are empty space in our output image set
+        # the freebox tuple format is: outidx, x, y, w, h
+        freeboxes = [(0, 0, 0, size_w, size_h)]
+        numoutimages = 1
+
+        # full boxes are areas where we have placed images in the atlas
+        # the full box tuple format is: image, outidx, x, y, w, h, filename
+        fullboxes = []
+
+        # do the actual atlasing by sticking the largest images we can
+        # have into the smallest valid free boxes
+        for imageinfo in ims:
+            im = imageinfo[1]
+            imw, imh = im.size
+            imw += padding
+            imh += padding
+            if imw > size_w or imh > size_h:
+                Logger.error(
+                    'Atlas: image %s (%d by %d) is larger than the atlas size!'
+                    % (imageinfo[0], imw, imh))
+                return
+
+            inserted = False
+            while not inserted:
+                for idx, fb in enumerate(freeboxes):
+                    # find the smallest free box that will contain this image
+                    if fb[3] >= imw and fb[4] >= imh:
+                        # we found a valid spot! Remove the current
+                        # freebox, and split the leftover space into (up to)
+                        # two new freeboxes
+                        del freeboxes[idx]
+                        if fb[3] > imw:
+                            freeboxes.append((
+                                fb[0], fb[1] + imw, fb[2],
+                                fb[3] - imw, imh))
+
+                        if fb[4] > imh:
+                            freeboxes.append((
+                                fb[0], fb[1], fb[2] + imh,
+                                fb[3], fb[4] - imh))
+
+                        # keep this sorted!
+                        freeboxes = sorted(freeboxes,
+                                           key=lambda fb: fb[3] * fb[4])
+                        fullboxes.append((im,
+                                          fb[0], fb[1] + padding,
+                                          fb[2] + padding, imw - padding,
+                                          imh - padding, imageinfo[0]))
+                        inserted = True
+                        break
+
+                if not inserted:
+                    # oh crap - there isn't room in any of our free
+                    # boxes, so we have to add a new output image
+                    freeboxes.append((numoutimages, 0, 0, size_w, size_h))
+                    numoutimages += 1
+
+        # now that we've figured out where everything goes, make the output
+        # images and blit the source images to the appropriate locations
+        Logger.info('Atlas: create an {0}x{1} rgba image'.format(size_w,
+                                                                 size_h))
+        outimages = [Image.new('RGBA', (size_w, size_h))
+                     for i in range(0, int(numoutimages))]
+        for fb in fullboxes:
+            x, y = fb[2], fb[3]
+            out = outimages[fb[1]]
+            out.paste(fb[0], (fb[2], fb[3]))
+            w, h = fb[0].size
+            if padding > 1:
+                out.paste(fb[0].crop((0, 0, w, 1)), (x, y - 1))
+                out.paste(fb[0].crop((0, h - 1, w, h)), (x, y + h))
+                out.paste(fb[0].crop((0, 0, 1, h)), (x - 1, y))
+                out.paste(fb[0].crop((w - 1, 0, w, h)), (x + w, y))
+
+        # save the output images
+        for idx, outimage in enumerate(outimages):
+            outimage.save('%s-%d.png' % (outname, idx))
+
+        # write out an json file that says where everything ended up
+        meta = {}
+        for fb in fullboxes:
+            fn = '%s-%d.png' % (basename(outname), fb[1])
+            if fn not in meta:
+                d = meta[fn] = {}
+            else:
+                d = meta[fn]
+
+            # fb[6] contain the filename
+            if use_path:
+                # use the path with separators replaced by _
+                # example '../data/tiles/green_grass.png' becomes
+                # 'data_tiles_green_grass'
+                uid = splitext(fb[6])[0]
+                # remove leading dots and slashes
+                uid = uid.lstrip('./\\')
+                # replace remaining slashes with _
+                uid = uid.replace('/', '_').replace('\\', '_')
+            else:
+                # for example, '../data/tiles/green_grass.png'
+                # just get only 'green_grass' as the uniq id.
+                uid = splitext(basename(fb[6]))[0]
+
+            x, y, w, h = fb[2:6]
+            d[uid] = x, size_h - y - h, w, h
+
+        outfn = '%s.atlas' % outname
+        with open(outfn, 'w') as fd:
+            json.dump(meta, fd)
+
+        return outfn, meta
+
+
+if __name__ == '__main__':
+    """ Main line program. Process command line arguments
+    to make a new atlas. """
+
+    import sys
+    from glob import glob
+    argv = sys.argv[1:]
+    # earlier import of kivy has already called getopt to remove kivy system
+    # arguments from this line. That is all arguments up to the first '--'
+    if len(argv) < 3:
+        print('Usage: python -m kivy.atlas [-- [--use-path] '
+              '[--padding=2]] <outname> '
+              '<size|512x256> <img1.png> [<img2.png>, ...]')
+        sys.exit(1)
+
+    options = {'use_path': False}
+    while True:
+        option = argv[0]
+        if option == '--use-path':
+            options['use_path'] = True
+        elif option.startswith('--padding='):
+            options['padding'] = int(option.split('=', 1)[-1])
+        elif option[:2] == '--':
+            print('Unknown option {}'.format(option))
+            sys.exit(1)
+        else:
+            break
+        argv = argv[1:]
+
+    outname = argv[0]
+    try:
+        if 'x' in argv[1]:
+            size = list(map(int, argv[1].split('x', 1)))
+        else:
+            size = int(argv[1])
+    except ValueError:
+        print('Error: size must be an integer or <integer>x<integer>')
+        sys.exit(1)
+
+    filenames = [fname for fnames in argv[2:] for fname in glob(fnames)]
+    ret = Atlas.create(outname, filenames, size, **options)
+    if not ret:
+        print('Error while creating atlas!')
+        sys.exit(1)
+
+    fn, meta = ret
+    print('Atlas created at', fn)
+    print('%d image%s been created' % (len(meta),
+          's have' if len(meta) > 1 else ' has'))
diff --git a/kivy/base.py b/kivy/base.py
new file mode 100644
index 0000000..cbe693d
--- /dev/null
+++ b/kivy/base.py
@@ -0,0 +1,617 @@
+# pylint: disable=W0611
+'''
+Kivy Base
+=========
+
+This module contains the Kivy core functionality and is not intended for end
+users. Feel free to look through it, but bare in mind that calling any of
+these methods directly may result in an unpredictable behavior as the calls
+access directly the event loop of an application.
+'''
+
+__all__ = (
+    'EventLoop',
+    'EventLoopBase',
+    'ExceptionHandler',
+    'ExceptionManagerBase',
+    'ExceptionManager',
+    'runTouchApp',
+    'async_runTouchApp',
+    'stopTouchApp',
+)
+
+import sys
+import os
+from kivy.config import Config
+from kivy.logger import Logger
+from kivy.utils import platform
+from kivy.clock import Clock
+from kivy.event import EventDispatcher
+from kivy.lang import Builder
+from kivy.context import register_context
+
+# private vars
+EventLoop = None
+
+
+class ExceptionHandler(object):
+    '''Base handler that catches exceptions in :func:`runTouchApp`.
+    You can subclass and extend it as follows::
+
+        class E(ExceptionHandler):
+            def handle_exception(self, inst):
+                Logger.exception('Exception caught by ExceptionHandler')
+                return ExceptionManager.PASS
+
+        ExceptionManager.add_handler(E())
+
+    Then, all exceptions will be set to PASS, and logged to the console!
+    '''
+
+    def handle_exception(self, exception):
+        '''Called by :class:`ExceptionManagerBase` to handle a exception.
+
+        Defaults to returning :attr:`ExceptionManager.RAISE` that re-raises the
+        exception. Return :attr:`ExceptionManager.PASS` to indicate that the
+        exception was handled and should be ignored.
+
+        This may be called multiple times with the same exception, if
+        :attr:`ExceptionManager.RAISE` is returned as the exception bubbles
+        through multiple kivy exception handling levels.
+        '''
+        return ExceptionManager.RAISE
+
+
+class ExceptionManagerBase:
+    '''ExceptionManager manages exceptions handlers.'''
+
+    RAISE = 0
+    """The exception should be re-raised.
+    """
+    PASS = 1
+    """The exception should be ignored as it was handled by the handler.
+    """
+
+    def __init__(self):
+        self.handlers = []
+        self.policy = ExceptionManagerBase.RAISE
+
+    def add_handler(self, cls):
+        '''Add a new exception handler to the stack.'''
+        if cls not in self.handlers:
+            self.handlers.append(cls)
+
+    def remove_handler(self, cls):
+        '''Remove the exception handler from the stack.'''
+        if cls in self.handlers:
+            self.handlers.remove(cls)
+
+    def handle_exception(self, inst):
+        '''Called when an exception occurred in the :func:`runTouchApp`
+        main loop.'''
+        ret = self.policy
+        for handler in self.handlers:
+            r = handler.handle_exception(inst)
+            if r == ExceptionManagerBase.PASS:
+                ret = r
+        return ret
+
+
+#: Instance of a :class:`ExceptionManagerBase` implementation.
+ExceptionManager: ExceptionManagerBase = register_context(
+    'ExceptionManager', ExceptionManagerBase)
+"""The :class:`ExceptionManagerBase` instance that handles kivy exceptions.
+"""
+
+
+class EventLoopBase(EventDispatcher):
+    '''Main event loop. This loop handles the updating of input and
+    dispatching events.
+    '''
+
+    __events__ = ('on_start', 'on_pause', 'on_stop')
+
+    def __init__(self):
+        super(EventLoopBase, self).__init__()
+        self.quit = False
+        self.input_events = []
+        self.postproc_modules = []
+        self.status = 'idle'
+        self.stopping = False
+        self.input_providers = []
+        self.input_providers_autoremove = []
+        self.event_listeners = []
+        self.window = None
+        self.me_list = []
+
+    @property
+    def touches(self):
+        '''Return the list of all touches currently in down or move states.
+        '''
+        return self.me_list
+
+    def ensure_window(self):
+        '''Ensure that we have a window.
+        '''
+        import kivy.core.window  # NOQA
+        if not self.window:
+            Logger.critical('App: Unable to get a Window, abort.')
+            sys.exit(1)
+
+    def set_window(self, window):
+        '''Set the window used for the event loop.
+        '''
+        self.window = window
+
+    def add_input_provider(self, provider, auto_remove=False):
+        '''Add a new input provider to listen for touch events.
+        '''
+        if provider not in self.input_providers:
+            self.input_providers.append(provider)
+            if auto_remove:
+                self.input_providers_autoremove.append(provider)
+
+    def remove_input_provider(self, provider):
+        '''Remove an input provider.
+
+        .. versionchanged:: 2.1.0
+            Provider will be also removed if it exist in auto-remove list.
+        '''
+        if provider in self.input_providers:
+            self.input_providers.remove(provider)
+            if provider in self.input_providers_autoremove:
+                self.input_providers_autoremove.remove(provider)
+
+    def add_event_listener(self, listener):
+        '''Add a new event listener for getting touch events.
+        '''
+        if listener not in self.event_listeners:
+            self.event_listeners.append(listener)
+
+    def remove_event_listener(self, listener):
+        '''Remove an event listener from the list.
+        '''
+        if listener in self.event_listeners:
+            self.event_listeners.remove(listener)
+
+    def start(self):
+        '''Must be called before :meth:`EventLoopBase.run()`. This starts all
+        configured input providers.
+
+        .. versionchanged:: 2.1.0
+            Method can be called multiple times, but event loop will start only
+            once.
+        '''
+        if self.status == 'started':
+            return
+        self.status = 'started'
+        self.quit = False
+        Clock.start_clock()
+        for provider in self.input_providers:
+            provider.start()
+        self.dispatch('on_start')
+
+    def close(self):
+        '''Exit from the main loop and stop all configured
+        input providers.'''
+        self.quit = True
+        self.stop()
+        self.status = 'closed'
+
+    def stop(self):
+        '''Stop all input providers and call callbacks registered using
+        `EventLoop.add_stop_callback()`.
+
+        .. versionchanged:: 2.1.0
+            Method can be called multiple times, but event loop will stop only
+            once.
+        '''
+        if self.status != 'started':
+            return
+        # XXX stop in reverse order that we started them!! (like push
+        # pop), very important because e.g. wm_touch and WM_PEN both
+        # store old window proc and the restore, if order is messed big
+        # problem happens, crashing badly without error
+        for provider in reversed(self.input_providers[:]):
+            provider.stop()
+            self.remove_input_provider(provider)
+
+        # ensure any restart will not break anything later.
+        self.input_events = []
+
+        Clock.stop_clock()
+        self.stopping = False
+        self.status = 'stopped'
+        self.dispatch('on_stop')
+
+    def add_postproc_module(self, mod):
+        '''Add a postproc input module (DoubleTap, TripleTap, DeJitter
+        RetainTouch are defaults).'''
+        if mod not in self.postproc_modules:
+            self.postproc_modules.append(mod)
+
+    def remove_postproc_module(self, mod):
+        '''Remove a postproc module.'''
+        if mod in self.postproc_modules:
+            self.postproc_modules.remove(mod)
+
+    def remove_android_splash(self, *args):
+        '''Remove android presplash in SDL2 bootstrap.'''
+        try:
+            from android import remove_presplash
+            remove_presplash()
+        except ImportError:
+            Logger.warning(
+                'Base: Failed to import "android" module. '
+                'Could not remove android presplash.')
+            return
+
+    def post_dispatch_input(self, etype, me):
+        '''This function is called by :meth:`EventLoopBase.dispatch_input()`
+        when we want to dispatch an input event. The event is dispatched to
+        all listeners and if grabbed, it's dispatched to grabbed widgets.
+        '''
+        # update available list
+        if etype == 'begin':
+            self.me_list.append(me)
+        elif etype == 'end':
+            if me in self.me_list:
+                self.me_list.remove(me)
+        # dispatch to listeners
+        if not me.grab_exclusive_class:
+            for listener in self.event_listeners:
+                listener.dispatch('on_motion', etype, me)
+        # dispatch grabbed touch
+        if not me.is_touch:
+            # Non-touch event must be handled by the event manager
+            return
+        me.grab_state = True
+        for weak_widget in me.grab_list[:]:
+            # weak_widget is a weak reference to widget
+            wid = weak_widget()
+            if wid is None:
+                # object is gone, stop.
+                me.grab_list.remove(weak_widget)
+                continue
+            root_window = wid.get_root_window()
+            if wid != root_window and root_window is not None:
+                me.push()
+                try:
+                    root_window.transform_motion_event_2d(me, wid)
+                except AttributeError:
+                    me.pop()
+                    continue
+            me.grab_current = wid
+            wid._context.push()
+            if etype == 'begin':
+                # don't dispatch again touch in on_touch_down
+                # a down event are nearly uniq here.
+                # wid.dispatch('on_touch_down', touch)
+                pass
+            elif etype == 'update':
+                if wid._context.sandbox:
+                    with wid._context.sandbox:
+                        wid.dispatch('on_touch_move', me)
+                else:
+                    wid.dispatch('on_touch_move', me)
+            elif etype == 'end':
+                if wid._context.sandbox:
+                    with wid._context.sandbox:
+                        wid.dispatch('on_touch_up', me)
+                else:
+                    wid.dispatch('on_touch_up', me)
+            wid._context.pop()
+            me.grab_current = None
+            if wid != root_window and root_window is not None:
+                me.pop()
+        me.grab_state = False
+        me.dispatch_done()
+
+    def _dispatch_input(self, *ev):
+        # remove the save event for the touch if exist
+        if ev in self.input_events:
+            self.input_events.remove(ev)
+        self.input_events.append(ev)
+
+    def dispatch_input(self):
+        '''Called by :meth:`EventLoopBase.idle()` to read events from input
+        providers, pass events to postproc, and dispatch final events.
+        '''
+
+        # first, acquire input events
+        for provider in self.input_providers:
+            provider.update(dispatch_fn=self._dispatch_input)
+
+        # execute post-processing modules
+        for mod in self.postproc_modules:
+            self.input_events = mod.process(events=self.input_events)
+
+        # real dispatch input
+        input_events = self.input_events
+        pop = input_events.pop
+        post_dispatch_input = self.post_dispatch_input
+        while input_events:
+            post_dispatch_input(*pop(0))
+
+    def mainloop(self):
+        while not self.quit and self.status == 'started':
+            try:
+                self.idle()
+                if self.window:
+                    self.window.mainloop()
+            except BaseException as inst:
+                # use exception manager first
+                r = ExceptionManager.handle_exception(inst)
+                if r == ExceptionManager.RAISE:
+                    stopTouchApp()
+                    raise
+                else:
+                    pass
+
+    async def async_mainloop(self):
+        while not self.quit and self.status == 'started':
+            try:
+                await self.async_idle()
+                if self.window:
+                    self.window.mainloop()
+            except BaseException as inst:
+                # use exception manager first
+                r = ExceptionManager.handle_exception(inst)
+                if r == ExceptionManager.RAISE:
+                    stopTouchApp()
+                    raise
+                else:
+                    pass
+
+        Logger.info("Window: exiting mainloop and closing.")
+        self.close()
+
+    def idle(self):
+        '''This function is called after every frame. By default:
+
+           * it "ticks" the clock to the next frame.
+           * it reads all input and dispatches events.
+           * it dispatches `on_update`, `on_draw` and `on_flip` events to the
+             window.
+        '''
+
+        # update dt
+        Clock.tick()
+
+        # read and dispatch input from providers
+        if not self.quit:
+            self.dispatch_input()
+
+        # flush all the canvas operation
+        if not self.quit:
+            Builder.sync()
+
+        # tick before draw
+        if not self.quit:
+            Clock.tick_draw()
+
+        # flush all the canvas operation
+        if not self.quit:
+            Builder.sync()
+
+        if not self.quit:
+            window = self.window
+            if window and window.canvas.needs_redraw:
+                window.dispatch('on_draw')
+                window.dispatch('on_flip')
+
+        # don't loop if we don't have listeners !
+        if len(self.event_listeners) == 0:
+            Logger.error('Base: No event listeners have been created')
+            Logger.error('Base: Application will leave')
+            self.exit()
+            return False
+
+        return self.quit
+
+    async def async_idle(self):
+        '''Identical to :meth:`idle`, but instead used when running
+        within an async event loop.
+        '''
+
+        # update dt
+        await Clock.async_tick()
+
+        # read and dispatch input from providers
+        if not self.quit:
+            self.dispatch_input()
+
+        # flush all the canvas operation
+        if not self.quit:
+            Builder.sync()
+
+        # tick before draw
+        if not self.quit:
+            Clock.tick_draw()
+
+        # flush all the canvas operation
+        if not self.quit:
+            Builder.sync()
+
+        if not self.quit:
+            window = self.window
+            if window and window.canvas.needs_redraw:
+                window.dispatch('on_draw')
+                window.dispatch('on_flip')
+
+        # don't loop if we don't have listeners !
+        if len(self.event_listeners) == 0:
+            Logger.error('Base: No event listeners have been created')
+            Logger.error('Base: Application will leave')
+            self.exit()
+            return False
+
+        return self.quit
+
+    def run(self):
+        '''Main loop'''
+        while not self.quit:
+            self.idle()
+        self.exit()
+
+    def exit(self):
+        '''Close the main loop and close the window.'''
+        self.close()
+        if self.window:
+            self.window.close()
+
+    def on_stop(self):
+        '''Event handler for `on_stop` events which will be fired right
+        after all input providers have been stopped.'''
+        pass
+
+    def on_pause(self):
+        '''Event handler for `on_pause` which will be fired when
+        the event loop is paused.'''
+        pass
+
+    def on_start(self):
+        '''Event handler for `on_start` which will be fired right
+        after all input providers have been started.'''
+        pass
+
+
+#: EventLoop instance
+EventLoop = EventLoopBase()
+
+
+def _runTouchApp_prepare(widget=None):
+    from kivy.input import MotionEventFactory, kivy_postproc_modules
+
+    # Ok, we got one widget, and we are not in embedded mode
+    # so, user don't create the window, let's create it for him !
+    if widget:
+        EventLoop.ensure_window()
+
+    # Instance all configured input
+    for key, value in Config.items('input'):
+        Logger.debug('Base: Create provider from %s' % (str(value)))
+
+        # split value
+        args = str(value).split(',', 1)
+        if len(args) == 1:
+            args.append('')
+        provider_id, args = args
+        provider = MotionEventFactory.get(provider_id)
+        if provider is None:
+            Logger.warning('Base: Unknown <%s> provider' % str(provider_id))
+            continue
+
+        # create provider
+        p = provider(key, args)
+        if p:
+            EventLoop.add_input_provider(p, True)
+
+    # add postproc modules
+    for mod in list(kivy_postproc_modules.values()):
+        EventLoop.add_postproc_module(mod)
+
+    # add main widget
+    if widget and EventLoop.window:
+        if widget not in EventLoop.window.children:
+            EventLoop.window.add_widget(widget)
+
+    # start event loop
+    Logger.info('Base: Start application main loop')
+    EventLoop.start()
+
+    # remove presplash on the next frame
+    if platform == 'android':
+        Clock.schedule_once(EventLoop.remove_android_splash)
+
+    # in non-embedded mode, there are 2 issues
+    #
+    # 1. if user created a window, call the mainloop from window.
+    #    This is due to glut, it need to be called with
+    #    glutMainLoop(). Only FreeGLUT got a gluMainLoopEvent().
+    #    So, we are executing the dispatching function inside
+    #    a redisplay event.
+    #
+    # 2. if no window is created, we are dispatching event loop
+    #    ourself (previous behavior.)
+    #
+
+
+def runTouchApp(widget=None, embedded=False):
+    '''Static main function that starts the application loop.
+    You can access some magic via the following arguments:
+
+    See :mod:`kivy.app` for example usage.
+
+    :Parameters:
+        `<empty>`
+            To make dispatching work, you need at least one
+            input listener. If not, application will leave.
+            (MTWindow act as an input listener)
+
+        `widget`
+            If you pass only a widget, a MTWindow will be created
+            and your widget will be added to the window as the root
+            widget.
+
+        `embedded`
+            No event dispatching is done. This will be your job.
+
+        `widget + embedded`
+            No event dispatching is done. This will be your job but
+            we try to get the window (must be created by you beforehand)
+            and add the widget to it. Very useful for embedding Kivy
+            in another toolkit. (like Qt, check kivy-designed)
+
+    '''
+    _runTouchApp_prepare(widget=widget)
+
+    # we are in embedded mode, don't do dispatching.
+    if embedded:
+        return
+
+    try:
+        EventLoop.mainloop()
+    finally:
+        stopTouchApp()
+
+
+async def async_runTouchApp(widget=None, embedded=False, async_lib=None):
+    '''Identical to :func:`runTouchApp` but instead it is a coroutine
+    that can be run in an existing async event loop.
+
+    ``async_lib`` is the async library to use. See :mod:`kivy.app` for details
+    and example usage.
+
+    .. versionadded:: 2.0.0
+    '''
+    if async_lib is not None:
+        Clock.init_async_lib(async_lib)
+    _runTouchApp_prepare(widget=widget)
+
+    # we are in embedded mode, don't do dispatching.
+    if embedded:
+        return
+
+    try:
+        await EventLoop.async_mainloop()
+    finally:
+        stopTouchApp()
+
+
+def stopTouchApp():
+    '''Stop the current application by leaving the main loop.
+
+    See :mod:`kivy.app` for example usage.
+    '''
+    if EventLoop is None:
+        return
+    if EventLoop.status in ('stopped', 'closed'):
+        return
+    if EventLoop.status != 'started':
+        if not EventLoop.stopping:
+            EventLoop.stopping = True
+            Clock.schedule_once(lambda dt: stopTouchApp(), 0)
+        return
+    Logger.info('Base: Leaving application in progress...')
+    EventLoop.close()
diff --git a/kivy/cache.py b/kivy/cache.py
new file mode 100644
index 0000000..48d9cd0
--- /dev/null
+++ b/kivy/cache.py
@@ -0,0 +1,262 @@
+'''
+Cache manager
+=============
+
+The cache manager can be used to store python objects attached to a unique
+key. The cache can be controlled in two ways: with a object limit or a
+timeout.
+
+For example, we can create a new cache with a limit of 10 objects and a
+timeout of 5 seconds::
+
+    # register a new Cache
+    Cache.register('mycache', limit=10, timeout=5)
+
+    # create an object + id
+    key = 'objectid'
+    instance = Label(text=text)
+    Cache.append('mycache', key, instance)
+
+    # retrieve the cached object
+    instance = Cache.get('mycache', key)
+
+If the instance is NULL, the cache may have trashed it because you've
+not used the label for 5 seconds and you've reach the limit.
+'''
+
+from os import environ
+from kivy.logger import Logger
+from kivy.clock import Clock
+
+__all__ = ('Cache', )
+
+
+class Cache(object):
+    '''See module documentation for more information.
+    '''
+
+    _categories = {}
+    _objects = {}
+
+    @staticmethod
+    def register(category, limit=None, timeout=None):
+        '''Register a new category in the cache with the specified limit.
+
+        :Parameters:
+            `category`: str
+                Identifier of the category.
+            `limit`: int (optional)
+                Maximum number of objects allowed in the cache.
+                If None, no limit is applied.
+            `timeout`: double (optional)
+                Time after which to delete the object if it has not been used.
+                If None, no timeout is applied.
+        '''
+        Cache._categories[category] = {
+            'limit': limit,
+            'timeout': timeout}
+        Cache._objects[category] = {}
+        Logger.debug(
+            'Cache: register <%s> with limit=%s, timeout=%s' %
+            (category, str(limit), str(timeout)))
+
+    @staticmethod
+    def append(category, key, obj, timeout=None):
+        '''Add a new object to the cache.
+
+        :Parameters:
+            `category`: str
+                Identifier of the category.
+            `key`: str
+                Unique identifier of the object to store.
+            `obj`: object
+                Object to store in cache.
+            `timeout`: double (optional)
+                Time after which to delete the object if it has not been used.
+                If None, no timeout is applied.
+
+        :raises:
+            `ValueError`: If `None` is used as `key`.
+
+        .. versionchanged:: 2.0.0
+            Raises `ValueError` if `None` is used as `key`.
+
+        '''
+        # check whether obj should not be cached first
+        if getattr(obj, '_nocache', False):
+            return
+        if key is None:
+            # This check is added because of the case when key is None and
+            # one of purge methods gets called. Then loop in purge method will
+            # call Cache.remove with key None which then clears entire
+            # category from Cache making next iteration of loop to raise a
+            # KeyError because next key will not exist.
+            # See: https://github.com/kivy/kivy/pull/6950
+            raise ValueError('"None" cannot be used as key in Cache')
+        try:
+            cat = Cache._categories[category]
+        except KeyError:
+            Logger.warning('Cache: category <%s> does not exist' % category)
+            return
+
+        timeout = timeout or cat['timeout']
+
+        limit = cat['limit']
+
+        if limit is not None and len(Cache._objects[category]) >= limit:
+            Cache._purge_oldest(category)
+
+        Cache._objects[category][key] = {
+            'object': obj,
+            'timeout': timeout,
+            'lastaccess': Clock.get_time(),
+            'timestamp': Clock.get_time()}
+
+    @staticmethod
+    def get(category, key, default=None):
+        '''Get a object from the cache.
+
+        :Parameters:
+            `category`: str
+                Identifier of the category.
+            `key`: str
+                Unique identifier of the object in the store.
+            `default`: anything, defaults to None
+                Default value to be returned if the key is not found.
+        '''
+        try:
+            Cache._objects[category][key]['lastaccess'] = Clock.get_time()
+            return Cache._objects[category][key]['object']
+        except Exception:
+            return default
+
+    @staticmethod
+    def get_timestamp(category, key, default=None):
+        '''Get the object timestamp in the cache.
+
+        :Parameters:
+            `category`: str
+                Identifier of the category.
+            `key`: str
+                Unique identifier of the object in the store.
+            `default`: anything, defaults to None
+                Default value to be returned if the key is not found.
+        '''
+        try:
+            return Cache._objects[category][key]['timestamp']
+        except Exception:
+            return default
+
+    @staticmethod
+    def get_lastaccess(category, key, default=None):
+        '''Get the objects last access time in the cache.
+
+        :Parameters:
+            `category`: str
+                Identifier of the category.
+            `key`: str
+                Unique identifier of the object in the store.
+            `default`: anything, defaults to None
+                Default value to be returned if the key is not found.
+        '''
+        try:
+            return Cache._objects[category][key]['lastaccess']
+        except Exception:
+            return default
+
+    @staticmethod
+    def remove(category, key=None):
+        '''Purge the cache.
+
+        :Parameters:
+            `category`: str
+                Identifier of the category.
+            `key`: str (optional)
+                Unique identifier of the object in the store. If this
+                argument is not supplied, the entire category will be purged.
+        '''
+        try:
+            if key is not None:
+                del Cache._objects[category][key]
+                Logger.trace('Cache: Removed %s:%s from cache' %
+                             (category, key))
+            else:
+                Cache._objects[category] = {}
+                Logger.trace('Cache: Flushed category %s from cache' %
+                             category)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _purge_oldest(category, maxpurge=1):
+        Logger.trace('Cache: Remove oldest in %s' % category)
+        import heapq
+        time = Clock.get_time()
+        heap_list = []
+        for key in Cache._objects[category]:
+            obj = Cache._objects[category][key]
+            if obj['lastaccess'] == obj['timestamp'] == time:
+                continue
+            heapq.heappush(heap_list, (obj['lastaccess'], key))
+            Logger.trace('Cache: <<< %f' % obj['lastaccess'])
+        n = 0
+        while n <= maxpurge:
+            try:
+                n += 1
+                lastaccess, key = heapq.heappop(heap_list)
+                Logger.trace('Cache: %d => %s %f %f' %
+                             (n, key, lastaccess, Clock.get_time()))
+            except Exception:
+                return
+            Cache.remove(category, key)
+
+    @staticmethod
+    def _purge_by_timeout(dt):
+        curtime = Clock.get_time()
+
+        for category in Cache._objects:
+            if category not in Cache._categories:
+                continue
+            timeout = Cache._categories[category]['timeout']
+            if timeout is not None and dt > timeout:
+                # XXX got a lag ! that may be because the frame take lot of
+                # time to draw. and the timeout is not adapted to the current
+                # framerate. So, increase the timeout by two.
+                # ie: if the timeout is 1 sec, and framerate go to 0.7, newly
+                # object added will be automatically trashed.
+                timeout *= 2
+                Cache._categories[category]['timeout'] = timeout
+                continue
+
+            for key in list(Cache._objects[category].keys()):
+                lastaccess = Cache._objects[category][key]['lastaccess']
+                objtimeout = Cache._objects[category][key]['timeout']
+
+                # take the object timeout if available
+                if objtimeout is not None:
+                    timeout = objtimeout
+
+                # no timeout, cancel
+                if timeout is None:
+                    continue
+
+                if curtime - lastaccess > timeout:
+                    Logger.trace('Cache: Removed %s:%s from cache due to '
+                                 'timeout' % (category, key))
+                    Cache.remove(category, key)
+
+    @staticmethod
+    def print_usage():
+        '''Print the cache usage to the console.'''
+        print('Cache usage :')
+        for category in Cache._categories:
+            print(' * %s : %d / %s, timeout=%s' % (
+                category.capitalize(),
+                len(Cache._objects[category]),
+                str(Cache._categories[category]['limit']),
+                str(Cache._categories[category]['timeout'])))
+
+
+if 'KIVY_DOC_INCLUDE' not in environ:
+    # install the schedule clock for purging
+    Clock.schedule_interval(Cache._purge_by_timeout, 1)
diff --git a/kivy/clock.py b/kivy/clock.py
new file mode 100644
index 0000000..a52b3c9
--- /dev/null
+++ b/kivy/clock.py
@@ -0,0 +1,1172 @@
+'''
+Clock object
+============
+
+The :class:`Clock` object allows you to schedule a function call in the
+future; once or repeatedly at specified intervals. You can get the time
+elapsed between the scheduling and the calling of the callback via the
+`dt` argument::
+
+    # dt means delta-time
+    def my_callback(dt):
+        pass
+
+    # call my_callback every 0.5 seconds
+    Clock.schedule_interval(my_callback, 0.5)
+
+    # call my_callback in 5 seconds
+    Clock.schedule_once(my_callback, 5)
+
+    # call my_callback as soon as possible (usually next frame.)
+    Clock.schedule_once(my_callback)
+
+.. note::
+
+    If the callback returns False, the schedule will be canceled and won't
+    repeat.
+
+If you want to schedule a function to call with default arguments, you can use
+the `functools.partial
+<http://docs.python.org/library/functools.html#functools.partial>`_ python
+module::
+
+    from functools import partial
+
+    def my_callback(value, key, *largs):
+        pass
+
+    Clock.schedule_interval(partial(my_callback, 'my value', 'my key'), 0.5)
+
+Conversely, if you want to schedule a function that doesn't accept the dt
+argument, you can use a `lambda
+<http://docs.python.org/2/reference/expressions.html#lambda>`_ expression
+to write a short function that does accept dt. For Example::
+
+    def no_args_func():
+        print("I accept no arguments, so don't schedule me in the clock")
+
+    Clock.schedule_once(lambda dt: no_args_func(), 0.5)
+
+.. note::
+
+    You cannot unschedule an anonymous function unless you keep a
+    reference to it. It's better to add \\*args to your function
+    definition so that it can be called with an arbitrary number of
+    parameters.
+
+.. important::
+
+    The class method callback is weak-referenced: you are responsible for
+    keeping a reference to your original object/callback. If you don't keep a
+    reference, the ClockBase will never execute your callback. For
+    example::
+
+        class Foo(object):
+            def start(self):
+                Clock.schedule_interval(self.callback, 0.5)
+
+            def callback(self, dt):
+                print('In callback')
+
+        # A Foo object is created and the method start is called.
+        # Because no reference is kept to the instance returned from Foo(),
+        # the object will be collected by the Python Garbage Collector and
+        # your callback will be never called.
+        Foo().start()
+
+        # So you should do the following and keep a reference to the instance
+        # of foo until you don't need it anymore!
+        foo = Foo()
+        foo.start()
+
+
+.. _schedule-before-frame:
+
+Schedule before frame
+---------------------
+
+.. versionadded:: 1.0.5
+
+Sometimes you need to schedule a callback BEFORE the next frame. Starting
+from 1.0.5, you can use a timeout of -1::
+
+    Clock.schedule_once(my_callback, 0) # call after the next frame
+    Clock.schedule_once(my_callback, -1) # call before the next frame
+
+The Clock will execute all the callbacks with a timeout of -1 before the
+next frame even if you add a new callback with -1 from a running
+callback. However, :class:`Clock` has an iteration limit for these
+callbacks: it defaults to 10.
+
+If you schedule a callback that schedules a callback that schedules a ... etc
+more than 10 times, it will leave the loop and send a warning to the console,
+then continue after the next frame. This is implemented to prevent bugs from
+hanging or crashing the application.
+
+If you need to increase the limit, set the :attr:`max_iteration` property::
+
+    from kivy.clock import Clock
+    Clock.max_iteration = 20
+
+.. _triggered-events:
+
+Triggered Events
+----------------
+
+.. versionadded:: 1.0.5
+
+:meth:`CyClockBase.create_trigger` is an advanced method way to defer a
+callback. It functions exactly like :meth:`CyClockBase.schedule_once` and
+:meth:`CyClockBase.schedule_interval` except that it doesn't immediately
+schedule the callback. Instead, one schedules the callback using the
+:class:`ClockEvent` returned by it. This ensures that you can call the event
+multiple times but it won't be scheduled more than once. This is not the case
+with :meth:`CyClockBase.schedule_once`::
+
+    # will run the callback twice before the next frame
+    Clock.schedule_once(my_callback)
+    Clock.schedule_once(my_callback)
+
+    # will run the callback once before the next frame
+    event = Clock.create_trigger(my_callback)
+    event()
+    event()
+
+    # will also run the callback only once before the next frame
+    event = Clock.schedule_once(my_callback)  # now it's already scheduled
+    event()  # won't be scheduled again
+    event()
+
+In addition, it is more convenient to create and bind to
+the triggered event than using :meth:`CyClockBase.schedule_once` in a
+function::
+
+    from kivy.clock import Clock
+    from kivy.uix.widget import Widget
+
+    class Sample(Widget):
+        def __init__(self, **kwargs):
+            self._trigger = Clock.create_trigger(self.cb)
+            super(Sample, self).__init__(**kwargs)
+            self.bind(x=self._trigger, y=self._trigger)
+
+        def cb(self, *largs):
+            pass
+
+Even if x and y changes within one frame, the callback is only run once.
+
+Unscheduling
+-------------
+
+An event scheduled with :meth:`CyClockBase.schedule_once`,
+:meth:`CyClockBase.schedule_interval`, or with
+:meth:`CyClockBase.create_trigger` and then triggered can be unscheduled in
+multiple ways. E.g::
+
+    def my_callback(dt):
+        pass
+
+    # call my_callback every 0.5 seconds
+    event = Clock.schedule_interval(my_callback, 0.5)
+
+    # call my_callback in 5 seconds
+    event2 = Clock.schedule_once(my_callback, 5)
+
+    event_trig = Clock.create_trigger(my_callback, 5)
+    event_trig()
+
+    # unschedule using cancel
+    event.cancel()
+
+    # unschedule using Clock.unschedule
+    Clock.unschedule(event2)
+
+    # unschedule using Clock.unschedule with the callback
+    # NOT RECOMMENDED
+    Clock.unschedule(my_callback)
+
+The best way to unschedule a callback is with :meth:`ClockEvent.cancel`.
+:meth:`CyClockBase.unschedule` is mainly an alias for that for that function.
+However, if the original callback itself is passed to
+:meth:`CyClockBase.unschedule`, it'll unschedule all instances of that
+callback (provided ``all`` is True, the default, otherwise only the first match
+is removed).
+
+Calling :meth:`CyClockBase.unschedule` on the original callback is highly
+discouraged because it's significantly slower than when using the event.
+
+Clock Lifecycle
+---------------
+
+Kivy's clock has a lifecycle. By default, scheduling a callback after the Clock
+has ended will not raise an error, even though the callback may never be
+called. That's because most callbacks are like services, e.g. responding to a
+user button press - if the app is running the callbacks need to service the app
+and respond to the input, but once the app has stopped or is stopping, we can
+safely not process these events.
+
+Other events always need to be processed. E.g. another thread may request a
+callback in kivy's thread and then process some result. If the event is not
+processed in Kivy's thread because the app stopped, the second thread may
+block forever hanging the application as it exits.
+
+Consequently, we provide a API
+(:meth:`CyClockBase.create_lifecycle_aware_trigger`) for scheduling callbacks
+that raise a :class:`ClockNotRunningError` if the clock has stopped. If the
+scheduling succeeded it guarantees that one of its callbacks will be called.
+I.e. the new :meth:`CyClockBase.create_lifecycle_aware_trigger` accepts an
+additional ``clock_ended_callback`` parameter. Normally, ``callback`` will be
+called when the event is processed. But, if the clock is stopped before it can
+be processed, if the application exited normally (and the app was started) and
+the event wasn't canceled, and the callbacks are not garbage collected, then
+``clock_ended_callback`` will be called instead when the clock is stopped.
+
+That is, given these conditions, if :class:`ClockNotRunningError` was not
+raised when the event was scheduled, then one of these callbacks will be
+called - either ``callback`` if the event executed normally, or
+``clock_ended_callback`` if the clock is stopped while the event is scheduled.
+
+By default, events can be scheduled before the clock is started because it is
+assumed the clock will eventually be started when the app starts. I.e.
+calling :meth:`CyClockBase.create_lifecycle_aware_trigger` before the clock
+and application starts will succeed. But if the app never actually starts, then
+neither of the callbacks may be executed.
+
+.. versionadded:: 2.0.0
+    The lifecycle was added in 2.0.0
+
+Exception Handling
+------------------
+
+Kivy provides a exception handling manager,
+:attr:`~kivy.base.ExceptionManager`, to handle its internal exceptions
+including exceptions raised by clock callbacks, without crashing the
+application. By default when an exception is raised, the app will crash.
+But, if a handler is registered with the exception manager and the handler
+handles the exception, the app will not crash and will continue as normal.::
+
+    from kivy.base import ExceptionHandler, ExceptionManager
+    class MyHandler(ExceptionHandler):
+        def handle_exception(self, inst):
+            if isinstance(inst, ValueError):
+                Logger.exception('ValueError caught by MyHandler')
+                return ExceptionManager.PASS
+            return ExceptionManager.RAISE
+
+    ExceptionManager.add_handler(MyHandler())
+
+Then, all ValueError exceptions will be logged to the console and ignored.
+Similarly, if a scheduled clock callback raises a ValueError, other clock
+events will still be processed normally.
+
+If an event's callback raises an exception, before the exception handler is
+executed, the callback is immediately canceled.
+
+It still is possible for the app to be corrupted if kivy itself is the source
+of the exception. I.e. even with a handler that ignores exceptions and doesn't
+crash, the app may be in a corrupted state if the error originates from within
+Kivy itself. However, the exception handler can help protect the app from
+crashing and can help protect against user callbacks crashing the app.
+
+.. versionchanged:: 2.0.0
+    Prior to Kivy 2.0.0, an exception raised in a event's callback would
+    cause the clock to crash and subsequent events may or may not be executed.
+    Even if the exception was handled by an
+    :class:`~kivy.base.ExceptionHandler`, there was no guarantee that some
+    scheduled events would not be skipped.
+
+    From 2.0.0 onward, if a event's exception is handled by an
+    :class:`~kivy.base.ExceptionHandler`, other events will be shielded from
+    the exception and will execute normally.
+
+Scheduling from ``__del__``
+---------------------------
+
+It is not safe to schedule Clock events from a object's ``__del__`` or
+``__dealloc__`` method. If you must schedule a Clock call from this method, use
+:meth:`CyClockBase.schedule_del_safe` or
+:meth:`CyClockBase.schedule_lifecycle_aware_del_safe` instead.
+
+Threading and Callback Order
+-----------------------------
+
+Beginning with 1.10.0, all the events scheduled for the same frame, e.g.
+all the events scheduled in the same frame with a ``timeout`` of ``0``,
+well be executed in the order they were scheduled.
+
+Also, all the scheduling and canceling methods are fully thread safe and
+can be safely used from external threads.
+
+As a a consequence, calling :meth:`CyClockBase.unschedule` with the original
+callback is now significantly slower and highly discouraged. Instead, the
+returned events should be used to cancel. As a tradeoff, all the other methods
+are now significantly faster than before.
+
+Advanced Clock Details
+-----------------------
+
+The following section goes into the internal kivy clock details as well
+as the various clock options. It is meant only for advanced users.
+
+Fundamentally, the Kivy clock attempts to execute any scheduled callback
+rhythmically as determined by the specified fps (frame per second, see
+``maxfps`` in :mod:`~kivy.config`). That is, ideally, given e.g. a desired fps
+of 30, the clock will execute the callbacks at intervals of 1 / 30 seconds, or
+every 33.33 ms. All the callbacks in a frame are given the same timestamp,
+i.e. the ``dt`` passed to the callback are all the same and it's the difference
+in time between the start of this and the previous frame.
+
+Because of inherent indeterminism, the frames do not actually occur exactly
+at intervals of the fps and ``dt`` may be under or over the desired fps.
+Also, once the timeout is "close enough" to the desired timeout, as determined
+internally, Kivy will execute the callback in the current frame even when the
+"actual time" has not elapsed the ``timeout`` amount.
+
+Kivy offers now, since ``1.10.0``, multiple clocks with different behaviors.
+
+Default Clock
+^^^^^^^^^^^^^^
+
+The default clock (``default``) behaves as described above. When a callback
+with a timeout of zero or non-zero is scheduled, they are executed at the frame
+that is near the timeout, which is a function of the fps. So a timeout of zero
+would still result in a delay of one frame or about 1 / fps, typically a bit
+less but sometimes more depending on the CPU usage of the other events
+scheduled for that frame.
+
+In a test using a fps of 30, a callback with a timeout of 0, 0.001, and 0.05,
+resulted in a mean callback delay of 0.02487, 0.02488, and 0.05011 seconds,
+respectively. When tested with a fps of 600 the delay for 0.05 was similar,
+except the standard deviation was reduced resulting in overall better accuracy.
+
+Interruptible Clock
+^^^^^^^^^^^^^^^^^^^^
+
+The default clock suffers from the quantization problem, as frames occur only
+on intervals and any scheduled timeouts will not be able to occur during an
+interval. For example, with the timeout of 0.05, while the mean was 0.05011,
+its values ranged between 0.02548 - 0.07348 and a standard deviation of 0.002.
+Also, there's the minimum timeout of about 0.02487.
+
+The interruptible clock (``interrupt``) will execute timeouts even during a
+frame. So a timeout of zero will execute as quickly as possible and similarly
+a non-zero timeout will be executed even during the interval.
+
+This clock, and all the clocks described after this have an option,
+:attr:`ClockBaseInterruptBehavior.interupt_next_only`. When True, any of the
+behavior new behavior will only apply to the callbacks with a timeout of
+zero. Non-zero timeouts will behave like in the default clock. E.g. for this
+clock when True, only zero timeouts will execute during the the interval.
+
+In a test using a fps of 30, a callback with a timeout of 0, 0.001, and 0.05,
+resulted in a mean callback delay of 0.00013, 0.00013, and 0.04120 seconds,
+respectively when :attr:`ClockBaseInterruptBehavior.interupt_next_only` was
+False. Also, compared to the default clock the standard deviation was reduced.
+When :attr:`ClockBaseInterruptBehavior.interupt_next_only` was True, the values
+were 0.00010, 0.02414, and 0.05034, respectively.
+
+Free Clock
+^^^^^^^^^^^
+
+The interruptible clock may not be ideal for all cases because all the events
+are executed during the intervals and events are not executed anymore
+rhythmically as multiples of the fps. For example, there may not be any benefit
+for the graphics to update in a sub-interval, so the additional accuracy
+wastes CPU.
+
+The Free clock (``free_all``) solves this by having ``Clock.xxx_free`` versions
+of all the Clock scheduling methods. By free, we mean the event is free from
+the fps because it's not fps limited. E.g.
+:meth:`CyClockBaseFree.create_trigger_free` corresponds to
+:meth:`CyClockBase.create_trigger`. Only when an event scheduled using the
+``Clock.xxx_free`` methods is present will the clock interrupt and execute
+the events during the interval. So, if no ``free`` event is present the clock
+behaves like the ``default`` clock, otherwise it behaves like the ``interrupt``
+clock.
+
+In a test using a fps of 30, a callback with a timeout of 0s, 0.001s, and
+0.05s, resulted in a mean callback delay of 0.00012s, 0.00017s, and 0.04121s
+seconds, respectively when it was a free event and 0.02403s, 0.02405s, and
+0.04829s, respectively when it wasn't.
+
+Free Only Clock
+^^^^^^^^^^^^^^^^^
+
+The Free clock executes all events when a free event was scheduled. This
+results in normal events also being execute in the middle of the interval
+when a free event is scheduled. For example, above, when a free event was
+absent, a normal event with a 0.001s timeout was delayed for 0.02405s. However,
+if a free event happened to be also scheduled, the normal event was only
+delayed 0.00014s, which may be undesirable.
+
+The Free only clock (``free_only``) solves it by only executing free events
+during the interval and normal events are always executed like with the
+default clock. For example, in the presence of a free event, a normal event
+with a timeout of 0.001s still had a delay of 0.02406. So this clock,
+treats free and normal events independently, with normal events always being
+fps limited, but never the free events.
+
+Summary
+^^^^^^^^
+
+The kivy clock type to use can be set with the ``kivy_clock`` option the
+:mod:`~kivy.config`. If ``KIVY_CLOCK`` is present in the environment it
+overwrites the config selection. Its possible values are as follows:
+
+* When ``kivy_clock`` is ``default``, the normal clock, :class:`ClockBase`,
+  which limits callbacks to the maxfps quantization - is used.
+* When ``kivy_clock`` is ``interrupt``, a interruptible clock,
+  :class:`ClockBaseInterrupt`, which doesn't limit any callbacks to the
+  maxfps - is used. Callbacks will be executed at any time.
+* When ``kivy_clock`` is ``free_all``, a interruptible clock,
+  :class:`ClockBaseFreeInterruptAll`, which doesn't limit any callbacks to the
+  maxfps in the presence of free events, but in their absence it limits events
+  to the fps quantization interval - is used.
+* When ``kivy_clock`` is ``free_only``, a interruptible clock,
+  :class:`ClockBaseFreeInterruptAll`, which treats free and normal events
+  independently; normal events are fps limited while free events are not - is
+  used.
+
+Async clock support
+-------------------
+
+.. versionadded:: 2.0.0
+
+Experimental async support has been added in 2.0.0. The Clock now has a
+:meth:`ClockBaseBehavior.async_tick` and :meth:`ClockBaseBehavior.async_idle`
+coroutine method which is used by the kivy EventLoop when the kivy EventLoop is
+executed in a asynchronous manner. When used, the kivy clock does not
+block while idling.
+
+The async library to use is selected with the `KIVY_EVENTLOOP` environmental
+variable or by  calling :meth:`~kivy.clock.ClockBaseBehavior.init_async_lib`
+directly. The library can be one of `"asyncio"` when the standard library
+`asyncio` should be used, or `"trio"` if the trio library
+should be used. If not set it defaults to `"asyncio"`.
+
+See :mod:`~kivy.app` for example usage.
+'''
+
+__all__ = (
+    'Clock', 'ClockNotRunningError', 'ClockEvent', 'FreeClockEvent',
+    'CyClockBase', 'CyClockBaseFree', 'triggered',
+    'ClockBaseBehavior', 'ClockBaseInterruptBehavior',
+    'ClockBaseInterruptFreeBehavior', 'ClockBase', 'ClockBaseInterrupt',
+    'ClockBaseFreeInterruptAll', 'ClockBaseFreeInterruptOnly', 'mainthread')
+
+from sys import platform
+from os import environ
+from functools import wraps, partial
+from kivy.context import register_context
+from kivy.config import Config
+from kivy.logger import Logger
+from kivy.compat import clock as _default_time
+import time
+try:
+    from kivy._clock import CyClockBase, ClockEvent, FreeClockEvent, \
+        CyClockBaseFree, ClockNotRunningError
+except ImportError:
+    Logger.error(
+        'Clock: Unable to import kivy._clock. Have you perhaps forgotten to '
+        'compile kivy? Kivy contains Cython code which needs to be compiled. '
+        'A missing kivy._clock often indicates the Cython code has not been '
+        'compiled. Please follow the installation instructions and make sure '
+        'to compile Kivy')
+    raise
+
+from threading import Event as ThreadingEvent
+
+# some reading: http://gameprogrammingpatterns.com/game-loop.html
+
+
+def _get_sleep_obj():
+    pass
+
+
+try:
+    import ctypes
+    if platform in ('win32', 'cygwin'):
+        # Win32 Sleep function is only 10-millisecond resolution, so
+        # instead use a waitable timer object, which has up to
+        # 100-nanosecond resolution (hardware and implementation
+        # dependent, of course).
+
+        _kernel32 = ctypes.windll.kernel32
+
+        def _get_sleep_obj():  # noqa: F811
+            return _kernel32.CreateWaitableTimerA(None, True, None)
+
+        def _usleep(microseconds, obj=None):
+            delay = ctypes.c_longlong(int(-microseconds * 10))
+            _kernel32.SetWaitableTimer(
+                obj, ctypes.byref(delay), 0,
+                ctypes.c_void_p(), ctypes.c_void_p(), False)
+            _kernel32.WaitForSingleObject(obj, 0xffffffff)
+    else:
+        if platform == 'darwin':
+            _libc = ctypes.CDLL('libc.dylib')
+        else:
+            from ctypes.util import find_library
+            _libc = ctypes.CDLL(find_library('c'), use_errno=True)
+
+            def _libc_clock_gettime_wrapper():
+                from os import strerror
+
+                class struct_tv(ctypes.Structure):
+                    _fields_ = [('tv_sec', ctypes.c_long),
+                                ('tv_usec', ctypes.c_long)]
+
+                _clock_gettime = _libc.clock_gettime
+                _clock_gettime.argtypes = [ctypes.c_long,
+                                           ctypes.POINTER(struct_tv)]
+
+                if 'linux' in platform:
+                    _clockid = 4  # CLOCK_MONOTONIC_RAW (Linux specific)
+                elif 'freebsd' in platform:
+                    # clockid constants from sys/time.h
+                    # _clockid = 4 # CLOCK_MONOTONIC (FreeBSD specific)
+                    # 11: CLOCK_MONOTONIC_PRECISE (FreeBSD known OK for 10.2)
+                    _clockid = 11
+                    # _clockid = 12
+                    # 12: CLOCK_MONOTONIC_FAST (FreeBSD specific)
+                    Logger.debug('clock.py: {{{:s}}} clock ID {:d}'.format(
+                        platform, _clockid))
+                elif 'openbsd' in platform:
+                    _clockid = 3  # CLOCK_MONOTONIC
+                else:
+                    _clockid = 1  # CLOCK_MONOTONIC
+
+                tv = struct_tv()
+
+                def _time():
+                    if _clock_gettime(ctypes.c_long(_clockid),
+                                      ctypes.pointer(tv)) != 0:
+                        _ernno = ctypes.get_errno()
+                        raise OSError(_ernno, strerror(_ernno))
+                    return tv.tv_sec + (tv.tv_usec * 0.000000001)
+
+                return _time
+
+            _default_time = _libc_clock_gettime_wrapper()  # noqa: F811
+
+        _libc.usleep.argtypes = [ctypes.c_ulong]
+        _libc_usleep = _libc.usleep
+
+        def _usleep(microseconds, obj=None):
+            _libc_usleep(int(microseconds))
+
+except (OSError, ImportError, AttributeError):
+    # ImportError: ctypes is not available on python-for-android.
+    # AttributeError: ctypes is now available on python-for-android, but
+    #   "undefined symbol: clock_gettime". CF #3797
+    # OSError: if the libc cannot be read (like with buildbot: invalid ELF
+    # header)
+
+    def _usleep(microseconds, obj=None):
+        time.sleep(microseconds / 1000000.)
+
+
+class ClockBaseBehavior(object):
+    '''The base of the kivy clock.
+
+    :parameters:
+
+        `async_lib`: string
+            The async library to use when the clock is run asynchronously.
+            Can be one of, `"asyncio"` when the standard library asyncio
+            should be used, or `"trio"` if the trio library should be used.
+
+            It defaults to `'asyncio'` or the value in the environmental
+            variable `KIVY_EVENTLOOP` if set. :meth:`init_async_lib` can also
+            be called directly to set the library.
+    '''
+
+    _dt = 0.0001
+    _last_fps_tick = None
+    _start_tick = 0
+    _fps = 0
+    _rfps = 0
+    _fps_counter = 0
+    _rfps_counter = 0
+    _frames = 0
+    _frames_displayed = 0
+    _events_duration = 0
+    '''The measured time that it takes to process all the events etc, excepting
+    any sleep or waiting time. It is the average and is updated every 5
+    seconds.
+    '''
+
+    _duration_count = 0
+    _sleep_time = 0
+    _duration_ts0 = 0
+
+    MIN_SLEEP = 0.005
+    '''The minimum time to sleep. If the remaining time is less than this,
+    the event loop will continue.
+    '''
+    SLEEP_UNDERSHOOT = MIN_SLEEP - 0.001
+
+    _async_lib = None
+
+    _async_wait_for = None
+
+    def __init__(self, async_lib='asyncio', **kwargs):
+        self.init_async_lib(async_lib)
+        super(ClockBaseBehavior, self).__init__(**kwargs)
+        self._duration_ts0 = self._start_tick = self._last_tick = self.time()
+        self._max_fps = float(Config.getint('graphics', 'maxfps'))
+
+    def init_async_lib(self, lib):
+        """Manually sets the async library to use internally, when running in
+        a asynchronous manner.
+
+        This can be called anytime before the kivy event loop has started,
+        but not once the kivy App is running.
+
+        :parameters:
+
+            `lib`: string
+                The async library to use when the clock is run asynchronously.
+                Can be one of, `"asyncio"` when the standard library asyncio
+                should be used, or `"trio"` if the trio library should be used.
+        """
+        if lib == 'trio':
+            import trio
+            self._async_lib = trio
+
+            async def wait_for(coro, t):
+                with trio.move_on_after(t):
+                    await coro
+            self._async_wait_for = wait_for
+        elif lib == 'asyncio':
+            import asyncio
+            self._async_lib = asyncio
+            self._async_wait_for = asyncio.wait_for
+        else:
+            raise ValueError('async library {} not recognized'.format(lib))
+
+    @property
+    def frametime(self):
+        '''Time spent between the last frame and the current frame
+        (in seconds).
+
+        .. versionadded:: 1.8.0
+        '''
+        return self._dt
+
+    @property
+    def frames(self):
+        '''Number of internal frames (not necessarily drawn) from the start of
+        the clock.
+
+        .. versionadded:: 1.8.0
+        '''
+        return self._frames
+
+    @property
+    def frames_displayed(self):
+        '''Number of displayed frames from the start of the clock.
+        '''
+        return self._frames_displayed
+
+    def usleep(self, microseconds):
+        '''Sleeps for the number of microseconds.
+        '''
+        pass
+
+    def idle(self):
+        '''(internal) waits here until the next frame.
+        '''
+        fps = self._max_fps
+        if fps > 0:
+            min_sleep = self.get_resolution()
+            undershoot = 4 / 5. * min_sleep
+            usleep = self.usleep
+            ready = self._check_ready
+
+            done, sleeptime = ready(fps, min_sleep, undershoot)
+            while not done:
+                usleep(1000000 * sleeptime)
+                done, sleeptime = ready(fps, min_sleep, undershoot)
+
+        current = self.time()
+        self._dt = current - self._last_tick
+        self._last_tick = current
+        return current
+
+    async def async_idle(self):
+        '''(internal) async version of :meth:`idle`.
+        '''
+        fps = self._max_fps
+        if fps > 0:
+            min_sleep = self.get_resolution()
+            undershoot = 4 / 5. * min_sleep
+            ready = self._check_ready
+
+            slept = False
+            done, sleeptime = ready(fps, min_sleep, undershoot)
+            while not done:
+                slept = True
+                await self._async_lib.sleep(sleeptime)
+                done, sleeptime = ready(fps, min_sleep, undershoot)
+
+            if not slept:
+                await self._async_lib.sleep(0)
+        else:
+            await self._async_lib.sleep(0)
+
+        current = self.time()
+        self._dt = current - self._last_tick
+        self._last_tick = current
+        return current
+
+    def _check_ready(self, fps, min_sleep, undershoot):
+        sleeptime = 1 / fps - (self.time() - self._last_tick)
+        return sleeptime - undershoot <= min_sleep, sleeptime - undershoot
+
+    def tick(self):
+        '''Advance the clock to the next step. Must be called every frame.
+        The default clock has a tick() function called by the core Kivy
+        framework.'''
+        self.pre_idle()
+        ts = self.time()
+        self.post_idle(ts, self.idle())
+
+    async def async_tick(self):
+        '''async version of :meth:`tick`. '''
+        self.pre_idle()
+        ts = self.time()
+        current = await self.async_idle()
+        self.post_idle(ts, current)
+
+    def pre_idle(self):
+        '''Called before :meth:`idle` by :meth:`tick`.
+        '''
+        self._release_references()
+
+    def post_idle(self, ts, current):
+        '''Called after :meth:`idle` by :meth:`tick`.
+        '''
+        # tick the current time
+        self._frames += 1
+        self._fps_counter += 1
+
+        # compute how long the event processing takes
+        self._duration_count += 1
+        self._sleep_time += current - ts
+        t_tot = current - self._duration_ts0
+        if t_tot >= 1.:
+            self._events_duration = \
+                (t_tot - self._sleep_time) / float(self._duration_count)
+            self._duration_ts0 = current
+            self._sleep_time = self._duration_count = 0
+
+        # calculate fps things
+        if self._last_fps_tick is None:
+            self._last_fps_tick = current
+        elif current - self._last_fps_tick > 1:
+            d = float(current - self._last_fps_tick)
+            self._fps = self._fps_counter / d
+            self._rfps = self._rfps_counter
+            self._last_fps_tick = current
+            self._fps_counter = 0
+            self._rfps_counter = 0
+
+        # process event
+        self._process_events()
+
+        return self._dt
+
+    def tick_draw(self):
+        '''Tick the drawing counter.
+        '''
+        self._process_events_before_frame()
+        self._rfps_counter += 1
+        self._frames_displayed += 1
+
+    def get_fps(self):
+        '''Get the current average FPS calculated by the clock.
+        '''
+        return self._fps
+
+    def get_rfps(self):
+        '''Get the current "real" FPS calculated by the clock.
+        This counter reflects the real framerate displayed on the screen.
+
+        In contrast to get_fps(), this function returns a counter of the
+        number of frames, not the average of frames per second.
+        '''
+        return self._rfps
+
+    def get_time(self):
+        '''Get the last tick made by the clock.'''
+        return self._last_tick
+
+    def get_boottime(self):
+        '''Get the time in seconds from the application start.'''
+        return self._last_tick - self._start_tick
+
+    time = staticmethod(partial(_default_time))
+
+    def handle_exception(self, e):
+        from kivy.base import ExceptionManager
+
+        if ExceptionManager.handle_exception(e) == ExceptionManager.RAISE:
+            raise
+
+
+ClockBaseBehavior.time.__doc__ = \
+    '''Proxy method for :func:`~kivy.compat.clock`. '''
+
+
+class ClockBaseInterruptBehavior(ClockBaseBehavior):
+    '''A kivy clock which can be interrupted during a frame to execute events.
+    '''
+
+    interupt_next_only = False
+    _event = None
+    _async_event = None
+    _get_min_timeout_func = None
+
+    def __init__(self, interupt_next_only=False, **kwargs):
+        super(ClockBaseInterruptBehavior, self).__init__(**kwargs)
+        self._event = ThreadingEvent()
+        self.interupt_next_only = interupt_next_only
+        self._get_min_timeout_func = self.get_min_timeout
+
+    def init_async_lib(self, lib):
+        super(ClockBaseInterruptBehavior, self).init_async_lib(lib)
+        if lib == 'trio':
+            import trio
+            self._async_event = trio.Event()
+            # we don't know if this is called after things have already been
+            # scheduled, so don't delay for a full frame before processing
+            # events
+            self._async_event.set()
+        elif lib == 'asyncio':
+            import asyncio
+            self._async_event = asyncio.Event()
+            self._async_event.set()
+
+    def usleep(self, microseconds):
+        self._event.clear()
+        self._event.wait(microseconds / 1000000.)
+
+    async def async_usleep(self, microseconds):
+        self._async_event.clear()
+        await self._async_wait_for(
+            self._async_event.wait(), microseconds / 1000000.)
+
+    def on_schedule(self, event):
+        fps = self._max_fps
+        if not fps:
+            return
+
+        if not event.timeout or (
+                not self.interupt_next_only and event.timeout <=
+                1 / fps -  # remaining time
+                (self.time() - self._last_tick) +  # elapsed time
+                4 / 5. * self.get_resolution()):  # resolution fudge factor
+            self._event.set()
+            if self._async_event:
+                self._async_event.set()
+
+    def idle(self):
+        fps = self._max_fps
+        event = self._event
+        resolution = self.get_resolution()
+        if fps > 0:
+            done, sleeptime = self._check_ready(
+                fps, resolution, 4 / 5. * resolution, event)
+            if not done:
+                event.wait(sleeptime)
+
+        current = self.time()
+        self._dt = current - self._last_tick
+        self._last_tick = current
+        event.clear()
+        # anything scheduled from now on, if scheduled for the upcoming frame
+        # will cause a timeout of the event on the next idle due to on_schedule
+        # `self._last_tick = current` must happen before clear, otherwise the
+        # on_schedule computation is wrong when exec between the clear and
+        # the `self._last_tick = current` bytecode.
+        return current
+
+    async def async_idle(self):
+        fps = self._max_fps
+        event = self._async_event
+        resolution = self.get_resolution()
+        if fps > 0:
+            done, sleeptime = self._check_ready(
+                fps, resolution, 4 / 5. * resolution, event)
+            if not done:
+                await self._async_wait_for(event.wait(), sleeptime)
+            else:
+                await self._async_lib.sleep(0)
+        else:
+            await self._async_lib.sleep(0)
+
+        current = self.time()
+        self._dt = current - self._last_tick
+        self._last_tick = current
+        event.clear()
+        # anything scheduled from now on, if scheduled for the upcoming frame
+        # will cause a timeout of the event on the next idle due to on_schedule
+        # `self._last_tick = current` must happen before clear, otherwise the
+        # on_schedule computation is wrong when exec between the clear and
+        # the `self._last_tick = current` bytecode.
+        return current
+
+    def _check_ready(self, fps, min_sleep, undershoot, event):
+        if event.is_set():
+            return True, 0
+
+        t = self._get_min_timeout_func()
+        if not t:
+            return True, 0
+
+        if not self.interupt_next_only:
+            curr_t = self.time()
+            sleeptime = min(1 / fps - (curr_t - self._last_tick), t - curr_t)
+        else:
+            sleeptime = 1 / fps - (self.time() - self._last_tick)
+        return sleeptime - undershoot <= min_sleep, sleeptime - undershoot
+
+
+class ClockBaseInterruptFreeBehavior(ClockBaseInterruptBehavior):
+    '''A base class for the clock that interrupts the sleep interval for
+    free events.
+    '''
+
+    def __init__(self, **kwargs):
+        super(ClockBaseInterruptFreeBehavior, self).__init__(**kwargs)
+        self._get_min_timeout_func = self.get_min_free_timeout
+
+    def on_schedule(self, event):
+        if not event.free:  # only wake up for free events
+            return
+        # free events should use real time not frame time
+        event._last_dt = self.time()
+        return super(ClockBaseInterruptFreeBehavior,
+                     self).on_schedule(event)
+
+
+class ClockBase(ClockBaseBehavior, CyClockBase):
+    '''The ``default`` kivy clock. See module for details.
+    '''
+
+    _sleep_obj = None
+
+    def __init__(self, **kwargs):
+        super(ClockBase, self).__init__(**kwargs)
+        self._sleep_obj = _get_sleep_obj()
+
+    def usleep(self, microseconds):
+        _usleep(microseconds, self._sleep_obj)
+
+
+class ClockBaseInterrupt(ClockBaseInterruptBehavior, CyClockBase):
+    '''The ``interrupt`` kivy clock. See module for details.
+    '''
+
+    pass
+
+
+class ClockBaseFreeInterruptAll(
+        ClockBaseInterruptFreeBehavior, CyClockBaseFree):
+    '''The ``free_all`` kivy clock. See module for details.
+    '''
+
+    pass
+
+
+class ClockBaseFreeInterruptOnly(
+        ClockBaseInterruptFreeBehavior, CyClockBaseFree):
+    '''The ``free_only`` kivy clock. See module for details.
+    '''
+
+    def idle(self):
+        fps = self._max_fps
+        current = self.time()
+        event = self._event
+        if fps > 0:
+            min_sleep = self.get_resolution()
+            usleep = self.usleep
+            undershoot = 4 / 5. * min_sleep
+            min_t = self.get_min_free_timeout
+            interupt_next_only = self.interupt_next_only
+
+            sleeptime = 1 / fps - (current - self._last_tick)
+            while sleeptime - undershoot > min_sleep:
+                if event.is_set():
+                    do_free = True
+                else:
+                    t = min_t()
+                    if not t:
+                        do_free = True
+                    elif interupt_next_only:
+                        do_free = False
+                    else:
+                        sleeptime = min(sleeptime, t - current)
+                        do_free = sleeptime - undershoot <= min_sleep
+
+                if do_free:
+                    event.clear()
+                    self._process_free_events(current)
+                else:
+                    event.wait(sleeptime - undershoot)
+                current = self.time()
+                sleeptime = 1 / fps - (current - self._last_tick)
+
+        self._dt = current - self._last_tick
+        self._last_tick = current
+        event.clear()  # this needs to stay after _last_tick
+        return current
+
+    async def async_idle(self):
+        fps = self._max_fps
+        current = self.time()
+        event = self._async_event
+        if fps > 0:
+            min_sleep = self.get_resolution()
+            usleep = self.usleep
+            undershoot = 4 / 5. * min_sleep
+            min_t = self.get_min_free_timeout
+            interupt_next_only = self.interupt_next_only
+
+            sleeptime = 1 / fps - (current - self._last_tick)
+            slept = False
+            while sleeptime - undershoot > min_sleep:
+                if event.is_set():
+                    do_free = True
+                else:
+                    t = min_t()
+                    if not t:
+                        do_free = True
+                    elif interupt_next_only:
+                        do_free = False
+                    else:
+                        sleeptime = min(sleeptime, t - current)
+                        do_free = sleeptime - undershoot <= min_sleep
+
+                if do_free:
+                    event.clear()
+                    self._process_free_events(current)
+                else:
+                    slept = True
+                    await self._async_wait_for(
+                        event.wait(), sleeptime - undershoot)
+                current = self.time()
+                sleeptime = 1 / fps - (current - self._last_tick)
+
+            if not slept:
+                await self._async_lib.sleep(0)
+        else:
+            await self._async_lib.sleep(0)
+
+        self._dt = current - self._last_tick
+        self._last_tick = current
+        event.clear()  # this needs to stay after _last_tick
+        return current
+
+
+def mainthread(func):
+    '''Decorator that will schedule the call of the function for the next
+    available frame in the mainthread. It can be useful when you use
+    :class:`~kivy.network.urlrequest.UrlRequest` or when you do Thread
+    programming: you cannot do any OpenGL-related work in a thread.
+
+    Please note that this method will return directly and no result can be
+    returned::
+
+        @mainthread
+        def callback(self, *args):
+            print('The request succeeded!',
+                  'This callback is called in the main thread.')
+
+
+        self.req = UrlRequest(url='http://...', on_success=callback)
+
+    .. versionadded:: 1.8.0
+    '''
+    @wraps(func)
+    def delayed_func(*args, **kwargs):
+        def callback_func(dt):
+            func(*args, **kwargs)
+        Clock.schedule_once(callback_func, 0)
+    return delayed_func
+
+
+def triggered(timeout=0, interval=False):
+    '''Decorator that will trigger the call of the function at the specified
+    timeout, through the method :meth:`CyClockBase.create_trigger`. Subsequent
+    calls to the decorated function (while the timeout is active) are ignored.
+
+    It can be helpful when an expensive function (i.e. call to a server) can be
+    triggered by different methods. Setting a proper timeout will delay the
+    calling and only one of them will be triggered.
+
+        @triggered(timeout, interval=False)
+        def callback(id):
+            print('The callback has been called with id=%d' % id)
+
+        >> callback(id=1)
+        >> callback(id=2)
+        The callback has been called with id=2
+
+    The decorated callback can also be unscheduled using:
+
+        >> callback.cancel()
+
+    .. versionadded:: 1.10.1
+    '''
+
+    def wrapper_triggered(func):
+
+        _args = []
+        _kwargs = {}
+
+        def cb_function(dt):
+            func(*tuple(_args), **_kwargs)
+
+        cb_trigger = Clock.create_trigger(
+            cb_function,
+            timeout=timeout,
+            interval=interval)
+
+        @wraps(func)
+        def trigger_function(*args, **kwargs):
+            _args[:] = []
+            _args.extend(list(args))
+            _kwargs.clear()
+            _kwargs.update(kwargs)
+            cb_trigger()
+
+        def trigger_cancel():
+            cb_trigger.cancel()
+
+        setattr(trigger_function, 'cancel', trigger_cancel)
+
+        return trigger_function
+
+    return wrapper_triggered
+
+
+if 'KIVY_DOC_INCLUDE' in environ:
+    #: Instance of :class:`ClockBaseBehavior`.
+    Clock: ClockBase = None
+else:
+    _classes = {'default': ClockBase, 'interrupt': ClockBaseInterrupt,
+                'free_all': ClockBaseFreeInterruptAll,
+                'free_only': ClockBaseFreeInterruptOnly}
+    _clk = environ.get('KIVY_CLOCK', Config.get('kivy', 'kivy_clock'))
+    if _clk not in _classes:
+        raise Exception(
+            '{} is not a valid kivy clock. Valid clocks are {}'.format(
+                _clk, sorted(_classes.keys())))
+
+    Clock: ClockBase = register_context(
+        'Clock', _classes[_clk],
+        async_lib=environ.get('KIVY_EVENTLOOP', 'asyncio'))
+    '''The kivy Clock instance. See module documentation for details.
+    '''
diff --git a/kivy/compat.py b/kivy/compat.py
new file mode 100644
index 0000000..bc02c52
--- /dev/null
+++ b/kivy/compat.py
@@ -0,0 +1,82 @@
+'''
+Compatibility module for Python 2.7 and >= 3.4
+==============================================
+
+This module provides a set of utility types and functions for optimization and
+to aid in writing Python 2/3 compatible code.
+'''
+
+__all__ = ('PY2', 'clock', 'string_types', 'queue', 'iterkeys',
+           'itervalues', 'iteritems', 'isclose')
+
+import sys
+import time
+from math import isinf, fabs
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+try:
+    from math import isclose
+except ImportError:
+    isclose = None
+
+PY2 = False
+'''False, because we don't support Python 2 anymore.'''
+
+clock = None
+'''A clock with the highest available resolution on your current Operating
+System.'''
+
+string_types = str
+'''A utility type for detecting string in a Python 2/3 friendly way. For
+example:
+
+.. code-block:: python
+
+    if isinstance(s, string_types):
+        print("It's a string or unicode type")
+    else:
+        print("It's something else.")
+'''
+
+text_type = str
+
+#: unichr is just chr in py3, since all strings are unicode
+unichr = chr
+
+iterkeys = lambda d: iter(d.keys())
+itervalues = lambda d: iter(d.values())
+iteritems = lambda d: iter(d.items())
+
+
+clock = time.perf_counter
+
+
+def _isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
+    '''Measures whether two floats are "close" to each other. Identical to
+    https://docs.python.org/3.6/library/math.html#math.isclose, for older
+    versions of python.
+    '''
+
+    if a == b:  # short-circuit exact equality
+        return True
+
+    if rel_tol < 0.0 or abs_tol < 0.0:
+        raise ValueError('error tolerances must be non-negative')
+
+    # use cmath so it will work with complex or float
+    if isinf(abs(a)) or isinf(abs(b)):
+        # This includes the case of two infinities of opposite sign, or
+        # one infinity and one finite number. Two infinities of opposite sign
+        # would otherwise have an infinite relative tolerance.
+        return False
+    diff = fabs(b - a)
+
+    return (((diff <= fabs(rel_tol * b)) or
+             (diff <= fabs(rel_tol * a))) or
+            (diff <= abs_tol))
+
+
+if isclose is None:
+    isclose = _isclose
diff --git a/kivy/config.py b/kivy/config.py
new file mode 100644
index 0000000..163301f
--- /dev/null
+++ b/kivy/config.py
@@ -0,0 +1,969 @@
+'''
+Configuration object
+====================
+
+The :class:`Config` object is an instance of a modified Python ConfigParser.
+See the `ConfigParser documentation
+<http://docs.python.org/library/configparser.html>`_ for more information.
+
+Kivy has a configuration file which determines the default settings. In
+order to change these settings, you can alter this file manually or use
+the Config object. Please see the :ref:`Configure Kivy` section for more
+information.
+
+Applying configurations
+-----------------------
+
+Configuration options control the initialization of the :class:`~kivy.app.App`.
+In order to avoid situations where the config settings do not work or are not
+applied before window creation (like setting an initial window size),
+:meth:`Config.set <kivy.config.ConfigParser.set>` should be used before
+importing any other Kivy modules. Ideally, this means setting them right at
+the start of your main.py script.
+
+Alternatively, you can save these settings permanently using
+:meth:`Config.set <ConfigParser.set>` then
+:meth:`Config.write <ConfigParser.write>`. In this case, you will need to
+restart the app for the changes to take effect. Note that this approach will
+effect all Kivy apps system wide.
+
+Please note that no underscores (`_`) are allowed in the section name.
+
+Usage of the Config object
+--------------------------
+
+To read a configuration token from a particular section::
+
+    >>> from kivy.config import Config
+    >>> Config.getint('kivy', 'show_fps')
+    0
+
+Change the configuration and save it::
+
+    >>> Config.set('postproc', 'retain_time', '50')
+    >>> Config.write()
+
+For information on configuring your :class:`~kivy.app.App`, please see the
+:ref:`Application configuration` section.
+
+.. versionchanged:: 1.7.1
+    The ConfigParser should work correctly with utf-8 now. The values are
+    converted from ascii to unicode only when needed. The method get() returns
+    utf-8 strings.
+
+Changing configuration with environment variables
+-------------------------------------------------
+
+Since 1.11.0, it is now possible to change the configuration using
+environment variables. They take precedence on the loaded config.ini.
+The format is::
+
+    KCFG_<section>_<key> = <value>
+
+For example:
+
+    KCFG_GRAPHICS_FULLSCREEN=auto ...
+    KCFG_KIVY_LOG_LEVEL=warning ...
+
+Or in your file before any kivy import:
+
+    import os
+    os.environ["KCFG_KIVY_LOG_LEVEL"] = "warning"
+
+If you don't want to map any environment variables, you can disable
+the behavior::
+
+    os.environ["KIVY_NO_ENV_CONFIG"] = "1"
+
+
+.. _configuration-tokens:
+
+Available configuration tokens
+------------------------------
+
+.. |log_levels| replace::
+    'trace', 'debug', 'info', 'warning', 'error' or 'critical'
+
+:kivy:
+
+    `default_font`: list
+        Default fonts used for widgets displaying any text. It defaults to
+        ['Roboto', 'data/fonts/Roboto-Regular.ttf',
+        'data/fonts/Roboto-Italic.ttf', 'data/fonts/Roboto-Bold.ttf',
+        'data/fonts/Roboto-BoldItalic.ttf'].
+    `desktop`: int, 0 or 1
+        This option controls desktop OS specific features, such as enabling
+        drag-able scroll-bar in scroll views, disabling of bubbles in
+        TextInput etc. 0 is disabled, 1 is enabled.
+    `exit_on_escape`: int, 0 or 1
+        Enables exiting kivy when escape is pressed.
+        0 is disabled, 1 is enabled.
+    `pause_on_minimize`: int, 0 or 1
+        If set to `1`, the main loop is paused and the `on_pause` event
+        is dispatched when the window is minimized. This option is intended
+        for desktop use only. Defaults to `0`.
+    `keyboard_layout`: string
+        Identifier of the layout to use.
+    `keyboard_mode`: string
+        Specifies the keyboard mode to use. If can be one of the following:
+
+        * '' - Let Kivy choose the best option for your current platform.
+        * 'system' - real keyboard.
+        * 'dock' - one virtual keyboard docked to a screen side.
+        * 'multi' - one virtual keyboard for every widget request.
+        * 'systemanddock' - virtual docked keyboard plus input from real
+          keyboard.
+        * 'systemandmulti' - analogous.
+    `kivy_clock`: one of `default`, `interrupt`, `free_all`, `free_only`
+        The clock type to use with kivy. See :mod:`kivy.clock`.
+    `log_dir`: string
+        Path of log directory.
+    `log_enable`: int, 0 or 1
+        Activate file logging. 0 is disabled, 1 is enabled.
+    `log_level`: string, one of |log_levels|
+        Set the minimum log level to use.
+    `log_name`: string
+        Format string to use for the filename of log file.
+
+    `log_maxfiles`: int
+        Keep log_maxfiles recent logfiles while purging the log directory. Set
+        'log_maxfiles' to -1 to disable logfile purging (eg keep all logfiles).
+
+        .. note::
+            You end up with 'log_maxfiles + 1' logfiles because the logger
+            adds a new one after purging.
+
+    `window_icon`: string
+        Path of the window icon. Use this if you want to replace the default
+        pygame icon.
+
+:postproc:
+
+    `double_tap_distance`: float
+        Maximum distance allowed for a double tap, normalized inside the range
+        0 - 1000.
+    `double_tap_time`: int
+        Time allowed for the detection of double tap, in milliseconds.
+    `ignore`: list of tuples
+        List of regions where new touches are ignored.
+        This configuration token can be used to resolve hotspot problems
+        with DIY hardware. The format of the list must be::
+
+            ignore = [(xmin, ymin, xmax, ymax), ...]
+
+        All the values must be inside the range 0 - 1.
+    `jitter_distance`: int
+        Maximum distance for jitter detection, normalized inside the range 0
+        - 1000.
+    `jitter_ignore_devices`: string, separated with commas
+        List of devices to ignore from jitter detection.
+    `retain_distance`: int
+        If the touch moves more than is indicated by retain_distance, it will
+        not be retained. Argument should be an int between 0 and 1000.
+    `retain_time`: int
+        Time allowed for a retain touch, in milliseconds.
+    `triple_tap_distance`: float
+        Maximum distance allowed for a triple tap, normalized inside the range
+        0 - 1000.
+    `triple_tap_time`: int
+        Time allowed for the detection of triple tap, in milliseconds.
+
+:graphics:
+    `borderless`: int, one of 0 or 1
+        If set to `1`, removes the window border/decoration. Window resizing
+        must also be disabled to hide the resizing border.
+    `custom_titlebar`: int, one of 0 or 1
+        If set to `1`, removes the window border and allows user to set a Widget
+        as a titlebar
+        see :meth:`~kivy.core.window.WindowBase.set_custom_titlebar`
+        for detailed usage
+    `custom_titlebar_border`: int, defaults to 5
+        sets the how many pixles off the border should be used as the
+        rezising frame
+    `window_state`: string , one of 'visible', 'hidden', 'maximized'
+                    or 'minimized'
+
+        Sets the window state, defaults to 'visible'. This option is available
+        only for the SDL2 window provider and it should be used on desktop
+        OSes.
+    `fbo`: string, one of 'hardware', 'software' or 'force-hardware'
+        Selects the FBO backend to use.
+    `fullscreen`: int or string, one of 0, 1, 'fake' or 'auto'
+        Activate fullscreen. If set to `1`, a resolution of `width`
+        times `height` pixels will be used.
+        If set to `auto`, your current display's resolution will be
+        used instead. This is most likely what you want.
+        If you want to place the window in another display,
+        use `fake`, or set the `borderless` option from the graphics section,
+        then adjust `width`, `height`, `top` and `left`.
+    `height`: int
+        Height of the :class:`~kivy.core.window.Window`, not used if
+        `fullscreen` is set to `auto`.
+    `left`: int
+        Left position of the :class:`~kivy.core.window.Window`.
+    `maxfps`: int, defaults to 60
+        Maximum FPS allowed.
+
+        .. warning::
+            Setting maxfps to 0 will lead to max CPU usage.
+
+    'multisamples': int, defaults to 2
+        Sets the `MultiSample Anti-Aliasing (MSAA)
+        <http://en.wikipedia.org/wiki/Multisample_anti-aliasing>`_ level.
+        Increasing this value results in smoother graphics but at the cost of
+        processing time.
+
+        .. note::
+           This feature is limited by device hardware support and will have no
+           effect on devices which do not support the level of MSAA requested.
+
+    `position`: string, one of 'auto' or 'custom'
+        Position of the window on your display. If `auto` is used, you have no
+        control of the initial position: `top` and `left` are ignored.
+    `show_cursor`: int, one of 0 or 1
+        Set whether or not the cursor is shown on the window.
+    `top`: int
+        Top position of the :class:`~kivy.core.window.Window`.
+    `resizable`: int, one of 0 or 1
+        If 0, the window will have a fixed size. If 1, the window will be
+        resizable.
+    `rotation`: int, one of 0, 90, 180 or 270
+        Rotation of the :class:`~kivy.core.window.Window`.
+    `width`: int
+        Width of the :class:`~kivy.core.window.Window`, not used if
+        `fullscreen` is set to `auto`.
+    `minimum_width`: int
+        Minimum width to restrict the window to. (sdl2 only)
+    `minimum_height`: int
+        Minimum height to restrict the window to. (sdl2 only)
+    `min_state_time`: float, defaults to .035
+        Minimum time for widgets to display a given visual state.
+        This attrib is currently used by widgets like
+        :class:`~kivy.uix.dropdown.DropDown` &
+        :class:`~kivy.uix.behaviors.buttonbehavior.ButtonBehavior` to
+        make sure they display their current visual state for the given
+        time.
+    `allow_screensaver`: int, one of 0 or 1, defaults to 1
+        Allow the device to show a screen saver, or to go to sleep
+        on mobile devices. Only works for the sdl2 window provider.
+    `vsync`: `none`, empty value, or integers
+        Whether vsync is enabled, currently only used with sdl2 window.
+        Possible values are `none` or empty value -- leaves it unchanged,
+        ``0`` -- disables vsync, ``1`` or larger -- sets vsync interval,
+        ``-1`` sets adaptive vsync. It falls back to 1 if setting to ``2+``
+        or ``-1`` failed. See ``SDL_GL_SetSwapInterval``.
+    `verify_gl_main_thread`: int, 1 or 0, defaults to 1
+        Whether to check if code that changes any gl instructions is
+        running outside the main thread and then raise an error.
+
+:input:
+
+    You can create new input devices using this syntax::
+
+        # example of input provider instance
+        yourid = providerid,parameters
+
+        # example for tuio provider
+        default = tuio,127.0.0.1:3333
+        mytable = tuio,192.168.0.1:3334
+
+    .. seealso::
+
+        Check the providers in :mod:`kivy.input.providers` for the syntax to
+        use inside the configuration file.
+
+:widgets:
+
+    `scroll_distance`: int
+        Default value of the
+        :attr:`~kivy.uix.scrollview.ScrollView.scroll_distance`
+        property used by the :class:`~kivy.uix.scrollview.ScrollView` widget.
+        Check the widget documentation for more information.
+
+    `scroll_friction`: float
+        Default value of the
+        :attr:`~kivy.uix.scrollview.ScrollView.scroll_friction`
+        property used by the :class:`~kivy.uix.scrollview.ScrollView` widget.
+        Check the widget documentation for more information.
+
+        .. deprecated:: 1.7.0
+            Please use
+            :class:`~kivy.uix.scrollview.ScrollView.effect_cls` instead.
+
+    `scroll_timeout`: int
+        Default value of the
+        :attr:`~kivy.uix.scrollview.ScrollView.scroll_timeout`
+        property used by the  :class:`~kivy.uix.scrollview.ScrollView` widget.
+        Check the widget documentation for more information.
+
+    `scroll_stoptime`: int
+        Default value of the
+        :attr:`~kivy.uix.scrollview.ScrollView.scroll_stoptime`
+        property used by the :class:`~kivy.uix.scrollview.ScrollView` widget.
+        Check the widget documentation for more information.
+
+        .. deprecated:: 1.7.0
+            Please use
+            :class:`~kivy.uix.scrollview.ScrollView.effect_cls` instead.
+
+    `scroll_moves`: int
+        Default value of the
+        :attr:`~kivy.uix.scrollview.ScrollView.scroll_moves`
+        property used by the :class:`~kivy.uix.scrollview.ScrollView` widget.
+        Check the widget documentation for more information.
+
+        .. deprecated:: 1.7.0
+            Please use
+            :class:`~kivy.uix.scrollview.ScrollView.effect_cls` instead.
+
+:modules:
+
+    You can activate modules with this syntax::
+
+        modulename =
+
+    Anything after the = will be passed to the module as arguments.
+    Check the specific module's documentation for a list of accepted
+    arguments.
+
+.. versionchanged:: 2.1.0
+    `vsync` has been added to the graphics section.
+    `verify_gl_main_thread` has been added to the graphics section.
+
+.. versionchanged:: 1.10.0
+    `min_state_time`  and `allow_screensaver` have been added
+    to the `graphics` section.
+    `kivy_clock` has been added to the kivy section.
+    `default_font` has beed added to the kivy section.
+
+.. versionchanged:: 1.9.0
+    `borderless` and `window_state` have been added to the graphics section.
+    The `fake` setting of the `fullscreen` option has been deprecated,
+    use the `borderless` option instead.
+    `pause_on_minimize` has been added to the kivy section.
+
+.. versionchanged:: 1.8.0
+    `systemanddock` and `systemandmulti` has been added as possible values for
+    `keyboard_mode` in the kivy section. `exit_on_escape` has been added
+    to the kivy section.
+
+.. versionchanged:: 1.2.0
+    `resizable` has been added to graphics section.
+
+.. versionchanged:: 1.1.0
+    tuio no longer listens by default. Window icons are not copied to
+    user directory anymore. You can still set a new window icon by using the
+    ``window_icon`` config setting.
+
+.. versionchanged:: 1.0.8
+    `scroll_timeout`, `scroll_distance` and `scroll_friction` have been added.
+    `list_friction`, `list_trigger_distance` and `list_friction_bound`
+    have been removed. `keyboard_type` and `keyboard_layout` have been
+    removed from the widget. `keyboard_mode` and `keyboard_layout` have
+    been added to the kivy section.
+'''
+
+__all__ = ('Config', 'ConfigParser')
+
+try:
+    from ConfigParser import ConfigParser as PythonConfigParser
+except ImportError:
+    from configparser import RawConfigParser as PythonConfigParser
+from os import environ
+from os.path import exists
+from kivy import kivy_config_fn
+from kivy.logger import Logger, logger_config_update
+from collections import OrderedDict
+from kivy.utils import platform
+from kivy.compat import PY2, string_types
+from weakref import ref
+
+_is_rpi = exists('/opt/vc/include/bcm_host.h')
+
+# Version number of current configuration format
+KIVY_CONFIG_VERSION = 24
+
+Config = None
+'''The default Kivy configuration object. This is a :class:`ConfigParser`
+instance with the :attr:`~kivy.config.ConfigParser.name` set to 'kivy'.
+
+.. code-block:: python
+
+    Config = ConfigParser(name='kivy')
+
+'''
+
+
+class ConfigParser(PythonConfigParser, object):
+    '''Enhanced ConfigParser class that supports the addition of default
+    sections and default values.
+
+    By default, the kivy ConfigParser instance, :attr:`~kivy.config.Config`,
+    is named `'kivy'` and the ConfigParser instance used by the
+    :meth:`App.build_settings <~kivy.app.App.build_settings>` method is named
+    `'app'`.
+
+    :Parameters:
+        `name`: string
+            The name of the instance. See :attr:`name`. Defaults to `''`.
+
+    .. versionchanged:: 1.9.0
+        Each ConfigParser can now be :attr:`named <name>`. You can get the
+        ConfigParser associated with a name using :meth:`get_configparser`.
+        In addition, you can now control the config values with
+        :class:`~kivy.properties.ConfigParserProperty`.
+
+    .. versionadded:: 1.0.7
+    '''
+
+    def __init__(self, name='', **kwargs):
+        PythonConfigParser.__init__(self, **kwargs)
+        self._sections = OrderedDict()
+        self.filename = None
+        self._callbacks = []
+        self.name = name
+
+    def add_callback(self, callback, section=None, key=None):
+        '''Add a callback to be called when a specific section or key has
+        changed. If you don't specify a section or key, it will call the
+        callback for all section/key changes.
+
+        Callbacks will receive 3 arguments: the section, key and value.
+
+        .. versionadded:: 1.4.1
+        '''
+        if section is None and key is not None:
+            raise Exception('You cannot specify a key without a section')
+        self._callbacks.append((callback, section, key))
+
+    def remove_callback(self, callback, section=None, key=None):
+        '''Removes a callback added with :meth:`add_callback`.
+        :meth:`remove_callback` must be called with the same parameters as
+        :meth:`add_callback`.
+
+        Raises a `ValueError` if not found.
+
+        .. versionadded:: 1.9.0
+        '''
+        self._callbacks.remove((callback, section, key))
+
+    def _do_callbacks(self, section, key, value):
+        for callback, csection, ckey in self._callbacks:
+            if csection is not None and csection != section:
+                continue
+            elif ckey is not None and ckey != key:
+                continue
+            callback(section, key, value)
+
+    def read(self, filename):
+        '''Read only one filename. In contrast to the original ConfigParser of
+        Python, this one is able to read only one file at a time. The last
+        read file will be used for the :meth:`write` method.
+
+        .. versionchanged:: 1.9.0
+            :meth:`read` now calls the callbacks if read changed any values.
+
+        '''
+        if not isinstance(filename, string_types):
+            raise Exception('Only one filename is accepted ({})'.format(
+                string_types.__name__))
+        self.filename = filename
+        # If we try to open directly the configuration file in utf-8,
+        # we correctly get the unicode value by default.
+        # But, when we try to save it again, all the values we didn't changed
+        # are still unicode, and then the PythonConfigParser internal do
+        # a str() conversion -> fail.
+        # Instead we currently to the conversion to utf-8 when value are
+        # "get()", but we internally store them in ascii.
+        # with codecs.open(filename, 'r', encoding='utf-8') as f:
+        #    self.readfp(f)
+        old_vals = {sect: {k: v for k, v in self.items(sect)} for sect in
+                    self.sections()}
+        PythonConfigParser.read(self, filename)
+
+        # when reading new file, sections/keys are only increased, not removed
+        f = self._do_callbacks
+        for section in self.sections():
+            if section not in old_vals:  # new section
+                for k, v in self.items(section):
+                    f(section, k, v)
+                continue
+
+            old_keys = old_vals[section]
+            for k, v in self.items(section):  # just update new/changed keys
+                if k not in old_keys or v != old_keys[k]:
+                    f(section, k, v)
+
+    def set(self, section, option, value):
+        '''Functions similarly to PythonConfigParser's set method, except that
+        the value is implicitly converted to a string.
+        '''
+        e_value = value
+        if not isinstance(value, string_types):
+            # might be boolean, int, etc.
+            e_value = str(value)
+        ret = PythonConfigParser.set(self, section, option, e_value)
+        self._do_callbacks(section, option, value)
+        return ret
+
+    def setall(self, section, keyvalues):
+        '''Sets multiple key-value pairs in a section. keyvalues should be a
+        dictionary containing the key-value pairs to be set.
+        '''
+        for key, value in keyvalues.items():
+            self.set(section, key, value)
+
+    def get(self, section, option, **kwargs):
+        value = PythonConfigParser.get(self, section, option, **kwargs)
+        if PY2:
+            if type(value) is str:
+                return value.decode('utf-8')
+        return value
+
+    def setdefaults(self, section, keyvalues):
+        '''Set multiple key-value defaults in a section. keyvalues should be
+        a dictionary containing the new key-value defaults.
+        '''
+        self.adddefaultsection(section)
+        for key, value in keyvalues.items():
+            self.setdefault(section, key, value)
+
+    def setdefault(self, section, option, value):
+        '''Set the default value for an option in the specified section.
+        '''
+        if self.has_option(section, option):
+            return
+        self.set(section, option, value)
+
+    def getdefault(self, section, option, defaultvalue):
+        '''Get the value of an option in the specified section. If not found,
+        it will return the default value.
+        '''
+        if not self.has_section(section):
+            return defaultvalue
+        if not self.has_option(section, option):
+            return defaultvalue
+        return self.get(section, option)
+
+    def getdefaultint(self, section, option, defaultvalue):
+        '''Get the value of an option in the specified section. If not found,
+        it will return the default value. The value will always be
+        returned as an integer.
+
+        .. versionadded:: 1.6.0
+        '''
+        return int(self.getdefault(section, option, defaultvalue))
+
+    def adddefaultsection(self, section):
+        '''Add a section if the section is missing.
+        '''
+        assert("_" not in section)
+        if self.has_section(section):
+            return
+        self.add_section(section)
+
+    def write(self):
+        '''Write the configuration to the last file opened using the
+        :meth:`read` method.
+
+        Return True if the write finished successfully, False otherwise.
+        '''
+        if self.filename is None:
+            return False
+        try:
+            with open(self.filename, 'w') as fd:
+                PythonConfigParser.write(self, fd)
+        except IOError:
+            Logger.exception('Unable to write the config <%s>' % self.filename)
+            return False
+        return True
+
+    def update_config(self, filename, overwrite=False):
+        '''Upgrade the configuration based on a new default config file.
+        Overwrite any existing values if overwrite is True.
+        '''
+        pcp = PythonConfigParser()
+        pcp.read(filename)
+        confset = self.setall if overwrite else self.setdefaults
+        for section in pcp.sections():
+            confset(section, dict(pcp.items(section)))
+        self.write()
+
+    @staticmethod
+    def _register_named_property(name, widget_ref, *largs):
+        ''' Called by the ConfigParserProperty to register a property which
+        was created with a config name instead of a config object.
+
+        When a ConfigParser with this name is later created, the properties
+        are then notified that this parser now exists so they can use it.
+        If the parser already exists, the property is notified here. See
+        :meth:`~kivy.properties.ConfigParserProperty.set_config`.
+
+        :Parameters:
+            `name`: a non-empty string
+                The name of the ConfigParser that is associated with the
+                property. See :attr:`name`.
+            `widget_ref`: 2-tuple.
+                The first element is a reference to the widget containing the
+                property, the second element is the name of the property. E.g.:
+
+                    class House(Widget):
+                        address = ConfigParserProperty('', 'info', 'street',
+                            'directory')
+
+                Then, the first element is a ref to a House instance, and the
+                second is `'address'`.
+        '''
+        configs = ConfigParser._named_configs
+        try:
+            config, props = configs[name]
+        except KeyError:
+            configs[name] = (None, [widget_ref])
+            return
+
+        props.append(widget_ref)
+        if config:
+            config = config()
+        widget = widget_ref[0]()
+
+        if config and widget:  # associate this config with property
+            widget.property(widget_ref[1]).set_config(config)
+
+    @staticmethod
+    def get_configparser(name):
+        '''Returns the :class:`ConfigParser` instance whose name is `name`, or
+        None if not found.
+
+        :Parameters:
+            `name`: string
+                The name of the :class:`ConfigParser` instance to return.
+        '''
+        try:
+            config = ConfigParser._named_configs[name][0]
+            if config is not None:
+                config = config()
+                if config is not None:
+                    return config
+            del ConfigParser._named_configs[name]
+        except KeyError:
+            return None
+
+    # keys are configparser names, values are 2-tuple of (ref(configparser),
+    # widget_ref), where widget_ref is same as in _register_named_property
+    _named_configs = {}
+    _name = ''
+
+    @property
+    def name(self):
+        ''' The name associated with this ConfigParser instance, if not `''`.
+        Defaults to `''`. It can be safely changed dynamically or set to `''`.
+
+        When a ConfigParser is given a name, that config object can be
+        retrieved using :meth:`get_configparser`. In addition, that config
+        instance can also be used with a
+        :class:`~kivy.properties.ConfigParserProperty` instance that set its
+        `config` value to this name.
+
+        Setting more than one ConfigParser with the same name will raise a
+        `ValueError`.
+        '''
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        old_name = self._name
+        if value is old_name:
+            return
+        self._name = value
+        configs = ConfigParser._named_configs
+
+        if old_name:  # disconnect this parser from previously connected props
+            _, props = configs.get(old_name, (None, []))
+            for widget, prop in props:
+                widget = widget()
+                if widget:
+                    widget.property(prop).set_config(None)
+            configs[old_name] = (None, props)
+
+        if not value:
+            return
+
+        # if given new name, connect it with property that used this name
+        try:
+            config, props = configs[value]
+        except KeyError:
+            configs[value] = (ref(self), [])
+            return
+
+        if config is not None and config() is not None:
+            raise ValueError('A parser named {} already exists'.format(value))
+        for widget, prop in props:
+            widget = widget()
+            if widget:
+                widget.property(prop).set_config(self)
+        configs[value] = (ref(self), props)
+
+
+if not environ.get('KIVY_DOC_INCLUDE'):
+
+    #
+    # Read, analyse configuration file
+    # Support upgrade of older config file versions
+    #
+
+    # Create default configuration
+    Config = ConfigParser(name='kivy')
+    Config.add_callback(logger_config_update, 'kivy', 'log_level')
+
+    # Read config file if exist
+    if (exists(kivy_config_fn) and
+            'KIVY_USE_DEFAULTCONFIG' not in environ and
+            'KIVY_NO_CONFIG' not in environ):
+        try:
+            Config.read(kivy_config_fn)
+        except Exception as e:
+            Logger.exception('Core: error while reading local'
+                             'configuration')
+
+    version = Config.getdefaultint('kivy', 'config_version', 0)
+
+    # Add defaults section
+    Config.adddefaultsection('kivy')
+    Config.adddefaultsection('graphics')
+    Config.adddefaultsection('input')
+    Config.adddefaultsection('postproc')
+    Config.adddefaultsection('widgets')
+    Config.adddefaultsection('modules')
+    Config.adddefaultsection('network')
+
+    # Upgrade default configuration until we have the current version
+    need_save = False
+    if version != KIVY_CONFIG_VERSION and 'KIVY_NO_CONFIG' not in environ:
+        Logger.warning('Config: Older configuration version detected'
+                       ' ({0} instead of {1})'.format(
+                           version, KIVY_CONFIG_VERSION))
+        Logger.warning('Config: Upgrading configuration in progress.')
+        need_save = True
+
+    while version < KIVY_CONFIG_VERSION:
+        Logger.debug('Config: Upgrading from %d to %d' %
+                     (version, version + 1))
+
+        if version == 0:
+
+            # log level
+            Config.setdefault('kivy', 'keyboard_repeat_delay', '300')
+            Config.setdefault('kivy', 'keyboard_repeat_rate', '30')
+            Config.setdefault('kivy', 'log_dir', 'logs')
+            Config.setdefault('kivy', 'log_enable', '1')
+            Config.setdefault('kivy', 'log_level', 'info')
+            Config.setdefault('kivy', 'log_name', 'kivy_%y-%m-%d_%_.txt')
+            Config.setdefault('kivy', 'window_icon', '')
+
+            # default graphics parameters
+            Config.setdefault('graphics', 'display', '-1')
+            Config.setdefault('graphics', 'fullscreen', 'no')
+            Config.setdefault('graphics', 'height', '600')
+            Config.setdefault('graphics', 'left', '0')
+            Config.setdefault('graphics', 'maxfps', '0')
+            Config.setdefault('graphics', 'multisamples', '2')
+            Config.setdefault('graphics', 'position', 'auto')
+            Config.setdefault('graphics', 'rotation', '0')
+            Config.setdefault('graphics', 'show_cursor', '1')
+            Config.setdefault('graphics', 'top', '0')
+            Config.setdefault('graphics', 'width', '800')
+
+            # input configuration
+            Config.setdefault('input', 'mouse', 'mouse')
+
+            # activate native input provider in configuration
+            # from 1.0.9, don't activate mactouch by default, or app are
+            # unusable.
+            if platform == 'win':
+                Config.setdefault('input', 'wm_touch', 'wm_touch')
+                Config.setdefault('input', 'wm_pen', 'wm_pen')
+            elif platform == 'linux':
+                probesysfs = 'probesysfs'
+                if _is_rpi:
+                    probesysfs += ',provider=hidinput'
+                Config.setdefault('input', '%(name)s', probesysfs)
+
+            # input postprocessing configuration
+            Config.setdefault('postproc', 'double_tap_distance', '20')
+            Config.setdefault('postproc', 'double_tap_time', '250')
+            Config.setdefault('postproc', 'ignore', '[]')
+            Config.setdefault('postproc', 'jitter_distance', '0')
+            Config.setdefault('postproc', 'jitter_ignore_devices',
+                              'mouse,mactouch,')
+            Config.setdefault('postproc', 'retain_distance', '50')
+            Config.setdefault('postproc', 'retain_time', '0')
+
+            # default configuration for keyboard repetition
+            Config.setdefault('widgets', 'keyboard_layout', 'qwerty')
+            Config.setdefault('widgets', 'keyboard_type', '')
+            Config.setdefault('widgets', 'list_friction', '10')
+            Config.setdefault('widgets', 'list_friction_bound', '20')
+            Config.setdefault('widgets', 'list_trigger_distance', '5')
+
+        elif version == 1:
+            Config.set('graphics', 'maxfps', '60')
+
+        elif version == 2:
+            # was a version to automatically copy windows icon in the user
+            # directory, but it's now not used anymore. User can still change
+            # the window icon by touching the config.
+            pass
+
+        elif version == 3:
+            # add token for scrollview
+            Config.setdefault('widgets', 'scroll_timeout', '55')
+            Config.setdefault('widgets', 'scroll_distance', '20')
+            Config.setdefault('widgets', 'scroll_friction', '1.')
+
+            # remove old list_* token
+            Config.remove_option('widgets', 'list_friction')
+            Config.remove_option('widgets', 'list_friction_bound')
+            Config.remove_option('widgets', 'list_trigger_distance')
+
+        elif version == 4:
+            Config.remove_option('widgets', 'keyboard_type')
+            Config.remove_option('widgets', 'keyboard_layout')
+
+            # add keyboard token
+            Config.setdefault('kivy', 'keyboard_mode', '')
+            Config.setdefault('kivy', 'keyboard_layout', 'qwerty')
+
+        elif version == 5:
+            Config.setdefault('graphics', 'resizable', '1')
+
+        elif version == 6:
+            # if the timeout is still the default value, change it
+            Config.setdefault('widgets', 'scroll_stoptime', '300')
+            Config.setdefault('widgets', 'scroll_moves', '5')
+
+        elif version == 7:
+            # desktop bool indicating whether to use desktop specific features
+            is_desktop = int(platform in ('win', 'macosx', 'linux'))
+            Config.setdefault('kivy', 'desktop', is_desktop)
+            Config.setdefault('postproc', 'triple_tap_distance', '20')
+            Config.setdefault('postproc', 'triple_tap_time', '375')
+
+        elif version == 8:
+            if Config.getint('widgets', 'scroll_timeout') == 55:
+                Config.set('widgets', 'scroll_timeout', '250')
+
+        elif version == 9:
+            Config.setdefault('kivy', 'exit_on_escape', '1')
+
+        elif version == 10:
+            Config.set('graphics', 'fullscreen', '0')
+            Config.setdefault('graphics', 'borderless', '0')
+
+        elif version == 11:
+            Config.setdefault('kivy', 'pause_on_minimize', '0')
+
+        elif version == 12:
+            Config.setdefault('graphics', 'window_state', 'visible')
+
+        elif version == 13:
+            Config.setdefault('graphics', 'minimum_width', '0')
+            Config.setdefault('graphics', 'minimum_height', '0')
+
+        elif version == 14:
+            Config.setdefault('graphics', 'min_state_time', '.035')
+
+        elif version == 15:
+            Config.setdefault('kivy', 'kivy_clock', 'default')
+
+        elif version == 16:
+            Config.setdefault('kivy', 'default_font', [
+                'Roboto',
+                'data/fonts/Roboto-Regular.ttf',
+                'data/fonts/Roboto-Italic.ttf',
+                'data/fonts/Roboto-Bold.ttf',
+                'data/fonts/Roboto-BoldItalic.ttf'])
+
+        elif version == 17:
+            Config.setdefault('graphics', 'allow_screensaver', '1')
+
+        elif version == 18:
+            Config.setdefault('kivy', 'log_maxfiles', '100')
+
+        elif version == 19:
+            Config.setdefault('graphics', 'shaped', '0')
+            Config.setdefault(
+                'kivy', 'window_shape',
+                'data/images/defaultshape.png'
+            )
+
+        elif version == 20:
+            Config.setdefault('network', 'useragent', 'curl')
+
+        elif version == 21:
+            Config.setdefault('graphics', 'vsync', '')
+
+        elif version == 22:
+            Config.setdefault('graphics', 'verify_gl_main_thread', '1')
+
+        elif version == 23:
+            Config.setdefault('graphics', 'custom_titlebar', '0')
+            Config.setdefault('graphics', 'custom_titlebar_border', '5')
+
+        else:
+            # for future.
+            break
+
+        # Pass to the next version
+        version += 1
+
+    # Indicate to the Config that we've upgrade to the latest version.
+    Config.set('kivy', 'config_version', KIVY_CONFIG_VERSION)
+
+    # Now, activate log file
+    Logger.logfile_activated = bool(Config.getint('kivy', 'log_enable'))
+
+    # If no configuration exist, write the default one.
+    if ((not exists(kivy_config_fn) or need_save) and
+            'KIVY_NO_CONFIG' not in environ):
+        try:
+            Config.filename = kivy_config_fn
+            Config.write()
+        except Exception as e:
+            Logger.exception('Core: Error while saving default config file')
+
+    # Load configuration from env
+    if environ.get('KIVY_NO_ENV_CONFIG', '0') != '1':
+        for key, value in environ.items():
+            if not key.startswith("KCFG_"):
+                continue
+            try:
+                _, section, name = key.split("_", 2)
+            except ValueError:
+                Logger.warning((
+                    "Config: Environ `{}` invalid format, "
+                    "must be KCFG_section_name").format(key))
+                continue
+
+            # extract and check section
+            section = section.lower()
+            if not Config.has_section(section):
+                Logger.warning(
+                    "Config: Environ `{}`: unknown section `{}`".format(
+                        key, section))
+                continue
+
+            # extract and check the option name
+            name = name.lower()
+            sections_to_check = {
+                "kivy", "graphics", "widgets", "postproc", "network"}
+            if (section in sections_to_check and
+                    not Config.has_option(section, name)):
+                Logger.warning((
+                    "Config: Environ `{}` unknown `{}` "
+                    "option in `{}` section.").format(
+                        key, name, section))
+                # we don't avoid to set an unknown option, because maybe
+                # an external modules or widgets (in garden?) may want to
+                # save its own configuration here.
+
+            Config.set(section, name, value)
diff --git a/kivy/context.py b/kivy/context.py
new file mode 100644
index 0000000..7d6e88e
--- /dev/null
+++ b/kivy/context.py
@@ -0,0 +1,102 @@
+'''
+Context
+=======
+
+.. versionadded:: 1.8.0
+
+.. warning::
+
+    This is experimental and subject to change as long as this warning notice
+    is present.
+
+Kivy has a few "global" instances that are used directly by many pieces of the
+framework: `Cache`, `Builder`, `Clock`.
+
+TODO: document this module.
+
+'''
+
+__all__ = ('Context', 'ProxyContext', 'register_context',
+           'get_current_context')
+
+_contexts = {}
+_default_context = None
+_context_stack = []
+
+
+class ProxyContext(object):
+
+    __slots__ = ['_obj']
+
+    def __init__(self, obj):
+        object.__init__(self)
+        object.__setattr__(self, '_obj', obj)
+
+    def __getattribute__(self, name):
+        return getattr(object.__getattribute__(self, '_obj'), name)
+
+    def __delattr__(self, name):
+        delattr(object.__getattribute__(self, '_obj'), name)
+
+    def __setattr__(self, name, value):
+        setattr(object.__getattribute__(self, '_obj'), name, value)
+
+    def __bool__(self):
+        return bool(object.__getattribute__(self, '_obj'))
+
+    def __str__(self):
+        return str(object.__getattribute__(self, '_obj'))
+
+    def __repr__(self):
+        return repr(object.__getattribute__(self, '_obj'))
+
+
+class Context(dict):
+
+    def __init__(self, init=False):
+        dict.__init__(self)
+        self.sandbox = None
+        if not init:
+            return
+
+        for name in _contexts:
+            context = _contexts[name]
+            instance = context['cls'](*context['args'], **context['kwargs'])
+            self[name] = instance
+
+    def push(self):
+        _context_stack.append(self)
+        for name, instance in self.items():
+            object.__setattr__(_contexts[name]['proxy'], '_obj', instance)
+
+    def pop(self):
+        # After popping context from stack. Update proxy's _obj with
+        # instances in current context
+        _context_stack.pop(-1)
+        for name, instance in get_current_context().items():
+            object.__setattr__(_contexts[name]['proxy'], '_obj', instance)
+
+
+def register_context(name, cls, *args, **kwargs):
+    '''Register a new context.
+    '''
+    instance = cls(*args, **kwargs)
+    proxy = ProxyContext(instance)
+    _contexts[name] = {
+        'cls': cls,
+        'args': args,
+        'kwargs': kwargs,
+        'proxy': proxy}
+    _default_context[name] = instance
+    return proxy
+
+
+def get_current_context():
+    '''Return the current context.
+    '''
+    if not _context_stack:
+        return _default_context
+    return _context_stack[-1]
+
+
+_default_context = Context(init=False)
diff --git a/kivy/core/__init__.py b/kivy/core/__init__.py
new file mode 100644
index 0000000..6cfc364
--- /dev/null
+++ b/kivy/core/__init__.py
@@ -0,0 +1,247 @@
+'''
+Core Abstraction
+================
+
+This module defines the abstraction layers for our core providers and their
+implementations. For further information, please refer to
+:ref:`architecture` and the :ref:`providers` section of the documentation.
+
+In most cases, you shouldn't directly use a library that's already covered
+by the core abstraction. Always try to use our providers first.
+In case we are missing a feature or method, please let us know by
+opening a new Bug report instead of relying on your library.
+
+.. warning::
+    These are **not** widgets! These are just abstractions of the respective
+    functionality. For example, you cannot add a core image to your window.
+    You have to use the image **widget** class instead. If you're really
+    looking for widgets, please refer to :mod:`kivy.uix` instead.
+'''
+
+
+import os
+import sysconfig
+import sys
+import traceback
+import tempfile
+import subprocess
+import importlib
+import kivy
+from kivy.logger import Logger
+
+
+class CoreCriticalException(Exception):
+    pass
+
+
+def core_select_lib(category, llist, create_instance=False,
+                    base='kivy.core', basemodule=None):
+    if 'KIVY_DOC' in os.environ:
+        return
+    category = category.lower()
+    basemodule = basemodule or category
+    libs_ignored = []
+    errs = []
+    for option, modulename, classname in llist:
+        try:
+            # module activated in config ?
+            try:
+                if option not in kivy.kivy_options[category]:
+                    libs_ignored.append(modulename)
+                    Logger.debug(
+                        '{0}: Provider <{1}> ignored by config'.format(
+                            category.capitalize(), option))
+                    continue
+            except KeyError:
+                pass
+
+            # import module
+            mod = importlib.__import__(name='{2}.{0}.{1}'.format(
+                basemodule, modulename, base),
+                globals=globals(),
+                locals=locals(),
+                fromlist=[modulename], level=0)
+            cls = mod.__getattribute__(classname)
+
+            # ok !
+            Logger.info('{0}: Provider: {1}{2}'.format(
+                category.capitalize(), option,
+                '({0} ignored)'.format(libs_ignored) if libs_ignored else ''))
+            if create_instance:
+                cls = cls()
+            return cls
+
+        except ImportError as e:
+            errs.append((option, e, sys.exc_info()[2]))
+            libs_ignored.append(modulename)
+            Logger.debug('{0}: Ignored <{1}> (import error)'.format(
+                category.capitalize(), option))
+            Logger.trace('', exc_info=e)
+
+        except CoreCriticalException as e:
+            errs.append((option, e, sys.exc_info()[2]))
+            Logger.error('{0}: Unable to use {1}'.format(
+                category.capitalize(), option))
+            Logger.error(
+                '{0}: The module raised an important error: {1!r}'.format(
+                    category.capitalize(), e.message))
+            raise
+
+        except Exception as e:
+            errs.append((option, e, sys.exc_info()[2]))
+            libs_ignored.append(modulename)
+            Logger.trace('{0}: Unable to use {1}'.format(
+                category.capitalize(), option))
+            Logger.trace('', exc_info=e)
+
+    err = '\n'.join(['{} - {}: {}\n{}'.format(opt, e.__class__.__name__, e,
+                   ''.join(traceback.format_tb(tb))) for opt, e, tb in errs])
+    Logger.critical(
+        '{0}: Unable to find any valuable {0} provider. Please enable '
+        'debug logging (e.g. add -d if running from the command line, or '
+        'change the log level in the config) and re-run your app to '
+        'identify potential causes\n{1}'.format(category.capitalize(), err))
+
+
+def core_register_libs(category, libs, base='kivy.core'):
+    if 'KIVY_DOC' in os.environ:
+        return
+    category = category.lower()
+    kivy_options = kivy.kivy_options[category]
+    libs_loadable = {}
+    libs_ignored = []
+
+    for option, lib in libs:
+        # module activated in config ?
+        if option not in kivy_options:
+            Logger.debug('{0}: option <{1}> ignored by config'.format(
+                category.capitalize(), option))
+            libs_ignored.append(lib)
+            continue
+        libs_loadable[option] = lib
+
+    libs_loaded = []
+    for item in kivy_options:
+        try:
+            # import module
+            try:
+                lib = libs_loadable[item]
+            except KeyError:
+                continue
+            importlib.__import__(name='{2}.{0}.{1}'.format(category, lib, base),
+                       globals=globals(),
+                       locals=locals(),
+                       fromlist=[lib],
+                       level=0)
+
+            libs_loaded.append(lib)
+
+        except Exception as e:
+            Logger.trace('{0}: Unable to use <{1}> as loader!'.format(
+                category.capitalize(), option))
+            Logger.trace('', exc_info=e)
+            libs_ignored.append(lib)
+
+    Logger.info('{0}: Providers: {1} {2}'.format(
+        category.capitalize(),
+        ', '.join(libs_loaded),
+        '({0} ignored)'.format(
+            ', '.join(libs_ignored)) if libs_ignored else ''))
+    return libs_loaded
+
+
+def handle_win_lib_import_error(category, provider, mod_name):
+    if sys.platform != 'win32':
+        return
+
+    assert mod_name.startswith('kivy.')
+    kivy_root = os.path.dirname(kivy.__file__)
+    dirs = mod_name[5:].split('.')
+    mod_path = os.path.join(kivy_root, *dirs)
+
+    # get the full expected path to the compiled pyd file
+    # filename is <debug>.cp<major><minor>-<platform>.pyd
+    # https://github.com/python/cpython/blob/master/Doc/whatsnew/3.5.rst
+    if hasattr(sys, 'gettotalrefcount'):  # debug
+        mod_path += '._d'
+    mod_path += '.cp{}{}-{}.pyd'.format(
+        sys.version_info.major, sys.version_info.minor,
+        sysconfig.get_platform().replace('-', '_'))
+
+    # does the compiled pyd exist at all?
+    if not os.path.exists(mod_path):
+        Logger.debug(
+            '{}: Failed trying to import "{}" for provider {}. Compiled file '
+            'does not exist. Have you perhaps forgotten to compile Kivy, or '
+            'did not install all required dependencies?'.format(
+                category, provider, mod_path))
+        return
+
+    # tell user to provide dependency walker
+    env_var = 'KIVY_{}_DEPENDENCY_WALKER'.format(provider.upper())
+    if env_var not in os.environ:
+        Logger.debug(
+            '{0}: Failed trying to import the "{1}" provider from "{2}". '
+            'This error is often encountered when a dependency is missing,'
+            ' or if there are multiple copies of the same dependency dll on '
+            'the Windows PATH and they are incompatible with each other. '
+            'This can occur if you are mixing installations (such as different'
+            ' python installations, like anaconda python and a system python) '
+            'or if another unrelated program added its directory to the PATH. '
+            'Please examine your PATH and python installation for potential '
+            'issues. To further troubleshoot a "DLL load failed" error, '
+            'please download '
+            '"Dependency Walker" (64 or 32 bit version - matching your python '
+            'bitness) from dependencywalker.com and set the environment '
+            'variable {3} to the full path of the downloaded depends.exe file '
+            'and rerun your application to generate an error report'.
+            format(category, provider, mod_path, env_var))
+        return
+
+    depends_bin = os.environ[env_var]
+    if not os.path.exists(depends_bin):
+        raise ValueError('"{}" provided in {} does not exist'.format(
+            depends_bin, env_var))
+
+    # make file for the resultant log
+    fd, temp_file = tempfile.mkstemp(
+        suffix='.dwi', prefix='kivy_depends_{}_log_'.format(provider),
+        dir=os.path.expanduser('~/'))
+    os.close(fd)
+
+    Logger.info(
+        '{}: Running dependency walker "{}" on "{}" to generate '
+        'troubleshooting log. Please wait for it to complete'.format(
+            category, depends_bin, mod_path))
+    Logger.debug(
+        '{}: Dependency walker command is "{}"'.format(
+            category,
+            [depends_bin, '/c', '/od:{}'.format(temp_file), mod_path]))
+
+    try:
+        subprocess.check_output([
+            depends_bin, '/c', '/od:{}'.format(temp_file), mod_path])
+    except subprocess.CalledProcessError as exc:
+        if exc.returncode >= 0x00010000:
+            Logger.error(
+                '{}: Dependency walker failed with error code "{}". No '
+                'error report was generated'.
+                format(category, exc.returncode))
+            return
+
+    Logger.info(
+        '{}: dependency walker generated "{}" containing troubleshooting '
+        'information about provider {} and its failing file "{} ({})". You '
+        'can open the file in dependency walker to view any potential issues '
+        'and troubleshoot it yourself. '
+        'To share the file with the Kivy developers and request support, '
+        'please contact us at our support channels '
+        'https://kivy.org/doc/master/contact.html (not on github, unless '
+        'it\'s truly a bug). Make sure to provide the generated file as well '
+        'as the *complete* Kivy log being printed here. Keep in mind the '
+        'generated dependency walker log file contains paths to dlls on your '
+        'system used by kivy or its dependencies to help troubleshoot them, '
+        'and these paths may include your name in them. Please view the '
+        'log file in dependency walker before sharing to ensure you are not '
+        'sharing sensitive paths'.format(
+            category, temp_file, provider, mod_name, mod_path))
diff --git a/kivy/core/__pycache__/__init__.cpython-310.pyc b/kivy/core/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..e9e3611
Binary files /dev/null and b/kivy/core/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/audio/__init__.py b/kivy/core/audio/__init__.py
new file mode 100644
index 0000000..9e2f380
--- /dev/null
+++ b/kivy/core/audio/__init__.py
@@ -0,0 +1,244 @@
+'''
+Audio
+=====
+
+Load an audio sound and play it with::
+
+    from kivy.core.audio import SoundLoader
+
+    sound = SoundLoader.load('mytest.wav')
+    if sound:
+        print("Sound found at %s" % sound.source)
+        print("Sound is %.3f seconds" % sound.length)
+        sound.play()
+
+You should not use the Sound class directly. The class returned by
+:func:`SoundLoader.load` will be the best sound provider for that particular
+file type, so it might return different Sound classes depending the file type.
+
+Event dispatching and state changes
+-----------------------------------
+
+Audio is often processed in parallel to your code. This means you often need to
+enter the Kivy :func:`eventloop <kivy.base.EventLoopBase>` in order to allow
+events and state changes to be dispatched correctly.
+
+You seldom need to worry about this as Kivy apps typically always
+require this event loop for the GUI to remain responsive, but it is good to
+keep this in mind when debugging or running in a
+`REPL <https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop>`_
+(Read-eval-print loop).
+
+.. versionchanged:: 1.10.0
+    The pygst and gi providers have been removed.
+
+.. versionchanged:: 1.8.0
+    There are now 2 distinct Gstreamer implementations: one using Gi/Gst
+    working for both Python 2+3 with Gstreamer 1.0, and one using PyGST
+    working only for Python 2 + Gstreamer 0.10.
+
+.. note::
+
+    The core audio library does not support recording audio. If you require
+    this functionality, please refer to the
+    `audiostream <https://github.com/kivy/audiostream>`_ extension.
+
+'''
+
+__all__ = ('Sound', 'SoundLoader')
+
+from kivy.logger import Logger
+from kivy.event import EventDispatcher
+from kivy.core import core_register_libs
+from kivy.resources import resource_find
+from kivy.properties import StringProperty, NumericProperty, OptionProperty, \
+    AliasProperty, BooleanProperty, BoundedNumericProperty
+from kivy.utils import platform
+from kivy.setupconfig import USE_SDL2
+
+from sys import float_info
+
+
+class SoundLoader:
+    '''Load a sound, using the best loader for the given file type.
+    '''
+
+    _classes = []
+
+    @staticmethod
+    def register(classobj):
+        '''Register a new class to load the sound.'''
+        Logger.debug('Audio: register %s' % classobj.__name__)
+        SoundLoader._classes.append(classobj)
+
+    @staticmethod
+    def load(filename):
+        '''Load a sound, and return a Sound() instance.'''
+        rfn = resource_find(filename)
+        if rfn is not None:
+            filename = rfn
+        ext = filename.split('.')[-1].lower()
+        if '?' in ext:
+            ext = ext.split('?')[0]
+        for classobj in SoundLoader._classes:
+            if ext in classobj.extensions():
+                return classobj(source=filename)
+        Logger.warning('Audio: Unable to find a loader for <%s>' %
+                       filename)
+        return None
+
+
+class Sound(EventDispatcher):
+    '''Represents a sound to play. This class is abstract, and cannot be used
+    directly.
+
+    Use SoundLoader to load a sound.
+
+    :Events:
+        `on_play`: None
+            Fired when the sound is played.
+        `on_stop`: None
+            Fired when the sound is stopped.
+    '''
+
+    source = StringProperty(None)
+    '''Filename / source of your audio file.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`source` is a :class:`~kivy.properties.StringProperty` that defaults
+    to None and is read-only. Use the :meth:`SoundLoader.load` for loading
+    audio.
+    '''
+
+    volume = NumericProperty(1.)
+    '''Volume, in the range 0-1. 1 means full volume, 0 means mute.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`volume` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.
+    '''
+
+    pitch = BoundedNumericProperty(1., min=float_info.epsilon)
+    '''Pitch of a sound. 2 is an octave higher, .5 one below. This is only
+    implemented for SDL2 audio provider yet.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`pitch` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.
+    '''
+
+    state = OptionProperty('stop', options=('stop', 'play'))
+    '''State of the sound, one of 'stop' or 'play'.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`state` is a read-only :class:`~kivy.properties.OptionProperty`.'''
+
+    loop = BooleanProperty(False)
+    '''Set to True if the sound should automatically loop when it finishes.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`loop` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.'''
+
+    #
+    # deprecated
+    #
+    def _get_status(self):
+        return self.state
+    status = AliasProperty(
+        _get_status, None, bind=('state', ), deprecated=True)
+    '''
+    .. deprecated:: 1.3.0
+        Use :attr:`state` instead.
+    '''
+
+    def _get_filename(self):
+        return self.source
+    filename = AliasProperty(
+        _get_filename, None, bind=('source', ), deprecated=True)
+    '''
+    .. deprecated:: 1.3.0
+        Use :attr:`source` instead.
+    '''
+
+    __events__ = ('on_play', 'on_stop')
+
+    def on_source(self, instance, filename):
+        self.unload()
+        if filename is None:
+            return
+        self.load()
+
+    def get_pos(self):
+        '''
+        Returns the current position of the audio file.
+        Returns 0 if not playing.
+
+        .. versionadded:: 1.4.1
+        '''
+        return 0
+
+    def _get_length(self):
+        return 0
+
+    length = property(lambda self: self._get_length(),
+                      doc='Get length of the sound (in seconds).')
+
+    def load(self):
+        '''Load the file into memory.'''
+        pass
+
+    def unload(self):
+        '''Unload the file from memory.'''
+        pass
+
+    def play(self):
+        '''Play the file.'''
+        self.state = 'play'
+        self.dispatch('on_play')
+
+    def stop(self):
+        '''Stop playback.'''
+        self.state = 'stop'
+        self.dispatch('on_stop')
+
+    def seek(self, position):
+        '''Go to the <position> (in seconds).
+
+        .. note::
+            Most sound providers cannot seek when the audio is stopped.
+            Play then seek.
+        '''
+        pass
+
+    def on_play(self):
+        pass
+
+    def on_stop(self):
+        pass
+
+
+# Little trick here, don't activate gstreamer on window
+# seem to have lot of crackle or something...
+audio_libs = []
+if platform == 'android':
+    audio_libs += [('android', 'audio_android')]
+elif platform in ('macosx', 'ios'):
+    audio_libs += [('avplayer', 'audio_avplayer')]
+try:
+    from kivy.lib.gstplayer import GstPlayer  # NOQA
+    audio_libs += [('gstplayer', 'audio_gstplayer')]
+except ImportError:
+    pass
+audio_libs += [('ffpyplayer', 'audio_ffpyplayer')]
+if USE_SDL2:
+    audio_libs += [('sdl2', 'audio_sdl2')]
+else:
+    audio_libs += [('pygame', 'audio_pygame')]
+
+libs_loaded = core_register_libs('audio', audio_libs)
diff --git a/kivy/core/audio/__pycache__/__init__.cpython-310.pyc b/kivy/core/audio/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..1933bb1
Binary files /dev/null and b/kivy/core/audio/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/audio/__pycache__/audio_android.cpython-310.pyc b/kivy/core/audio/__pycache__/audio_android.cpython-310.pyc
new file mode 100644
index 0000000..a3cd8da
Binary files /dev/null and b/kivy/core/audio/__pycache__/audio_android.cpython-310.pyc differ
diff --git a/kivy/core/audio/__pycache__/audio_avplayer.cpython-310.pyc b/kivy/core/audio/__pycache__/audio_avplayer.cpython-310.pyc
new file mode 100644
index 0000000..817c619
Binary files /dev/null and b/kivy/core/audio/__pycache__/audio_avplayer.cpython-310.pyc differ
diff --git a/kivy/core/audio/__pycache__/audio_ffpyplayer.cpython-310.pyc b/kivy/core/audio/__pycache__/audio_ffpyplayer.cpython-310.pyc
new file mode 100644
index 0000000..4f250fd
Binary files /dev/null and b/kivy/core/audio/__pycache__/audio_ffpyplayer.cpython-310.pyc differ
diff --git a/kivy/core/audio/__pycache__/audio_gstplayer.cpython-310.pyc b/kivy/core/audio/__pycache__/audio_gstplayer.cpython-310.pyc
new file mode 100644
index 0000000..6c8b096
Binary files /dev/null and b/kivy/core/audio/__pycache__/audio_gstplayer.cpython-310.pyc differ
diff --git a/kivy/core/audio/__pycache__/audio_pygame.cpython-310.pyc b/kivy/core/audio/__pycache__/audio_pygame.cpython-310.pyc
new file mode 100644
index 0000000..0a9ca15
Binary files /dev/null and b/kivy/core/audio/__pycache__/audio_pygame.cpython-310.pyc differ
diff --git a/kivy/core/audio/audio_android.py b/kivy/core/audio/audio_android.py
new file mode 100644
index 0000000..1558aeb
--- /dev/null
+++ b/kivy/core/audio/audio_android.py
@@ -0,0 +1,104 @@
+"""
+AudioAndroid: Kivy audio implementation for Android using native API
+"""
+
+__all__ = ("SoundAndroidPlayer", )
+
+from jnius import autoclass, java_method, PythonJavaClass
+from android import api_version
+from kivy.core.audio import Sound, SoundLoader
+
+
+MediaPlayer = autoclass("android.media.MediaPlayer")
+AudioManager = autoclass("android.media.AudioManager")
+if api_version >= 21:
+    AudioAttributesBuilder = autoclass("android.media.AudioAttributes$Builder")
+
+
+class OnCompletionListener(PythonJavaClass):
+    __javainterfaces__ = ["android/media/MediaPlayer$OnCompletionListener"]
+    __javacontext__ = "app"
+
+    def __init__(self, callback, **kwargs):
+        super(OnCompletionListener, self).__init__(**kwargs)
+        self.callback = callback
+
+    @java_method("(Landroid/media/MediaPlayer;)V")
+    def onCompletion(self, mp):
+        self.callback()
+
+
+class SoundAndroidPlayer(Sound):
+    @staticmethod
+    def extensions():
+        return ("mp3", "mp4", "aac", "3gp", "flac", "mkv", "wav", "ogg", "m4a",
+                "gsm", "mid", "xmf", "mxmf", "rtttl", "rtx", "ota", "imy")
+
+    def __init__(self, **kwargs):
+        self._mediaplayer = None
+        self._completion_listener = None
+        super(SoundAndroidPlayer, self).__init__(**kwargs)
+
+    def load(self):
+        self.unload()
+        self._mediaplayer = MediaPlayer()
+        if api_version >= 21:
+            self._mediaplayer.setAudioAttributes(
+                AudioAttributesBuilder()
+                .setLegacyStreamType(AudioManager.STREAM_MUSIC)
+                .build())
+        else:
+            self._mediaplayer.setAudioStreamType(AudioManager.STREAM_MUSIC)
+        self._mediaplayer.setDataSource(self.source)
+        self._completion_listener = OnCompletionListener(
+            self._completion_callback
+        )
+        self._mediaplayer.setOnCompletionListener(self._completion_listener)
+        self._mediaplayer.prepare()
+
+    def unload(self):
+        if self._mediaplayer:
+            self._mediaplayer.release()
+            self._mediaplayer = None
+
+    def play(self):
+        if not self._mediaplayer:
+            return
+        self._mediaplayer.start()
+        super(SoundAndroidPlayer, self).play()
+
+    def stop(self):
+        if not self._mediaplayer:
+            return
+        self._mediaplayer.stop()
+        self._mediaplayer.prepare()
+
+    def seek(self, position):
+        if not self._mediaplayer:
+            return
+        self._mediaplayer.seekTo(float(position) * 1000)
+
+    def get_pos(self):
+        if self._mediaplayer:
+            return self._mediaplayer.getCurrentPosition() / 1000.
+        return super(SoundAndroidPlayer, self).get_pos()
+
+    def on_volume(self, instance, volume):
+        if self._mediaplayer:
+            volume = float(volume)
+            self._mediaplayer.setVolume(volume, volume)
+
+    def _completion_callback(self):
+        super(SoundAndroidPlayer, self).stop()
+
+    def _get_length(self):
+        if self._mediaplayer:
+            return self._mediaplayer.getDuration() / 1000.
+        return super(SoundAndroidPlayer, self)._get_length()
+
+    def on_loop(self, instance, loop):
+        if self._mediaplayer:
+            self._mediaplayer.setLooping(loop)
+
+
+SoundLoader.register(SoundAndroidPlayer)
diff --git a/kivy/core/audio/audio_avplayer.py b/kivy/core/audio/audio_avplayer.py
new file mode 100644
index 0000000..af3ff0c
--- /dev/null
+++ b/kivy/core/audio/audio_avplayer.py
@@ -0,0 +1,72 @@
+'''
+AudioAvplayer: implementation of Sound using pyobjus / AVFoundation.
+Works on iOS / OSX.
+'''
+
+__all__ = ('SoundAvplayer', )
+
+from kivy.core.audio import Sound, SoundLoader
+from pyobjus import autoclass
+from pyobjus.dylib_manager import load_framework, INCLUDE
+
+load_framework(INCLUDE.AVFoundation)
+AVAudioPlayer = autoclass("AVAudioPlayer")
+NSURL = autoclass("NSURL")
+NSString = autoclass("NSString")
+
+
+class SoundAvplayer(Sound):
+    @staticmethod
+    def extensions():
+        # taken from https://goo.gl/015kvU
+        return ("aac", "adts", "aif", "aiff", "aifc", "caf", "mp3", "mp4",
+                "m4a", "snd", "au", "sd2", "wav")
+
+    def __init__(self, **kwargs):
+        self._avplayer = None
+        super(SoundAvplayer, self).__init__(**kwargs)
+
+    def load(self):
+        self.unload()
+        fn = NSString.alloc().initWithUTF8String_(self.source)
+        url = NSURL.alloc().initFileURLWithPath_(fn)
+        self._avplayer = AVAudioPlayer.alloc().initWithContentsOfURL_error_(
+            url, None)
+
+    def unload(self):
+        self.stop()
+        self._avplayer = None
+
+    def play(self):
+        if not self._avplayer:
+            return
+        self._avplayer.play()
+        super(SoundAvplayer, self).play()
+
+    def stop(self):
+        if not self._avplayer:
+            return
+        self._avplayer.stop()
+        super(SoundAvplayer, self).stop()
+
+    def seek(self, position):
+        if not self._avplayer:
+            return
+        self._avplayer.playAtTime_(float(position))
+
+    def get_pos(self):
+        if self._avplayer:
+            return self._avplayer.currentTime
+        return super(SoundAvplayer, self).get_pos()
+
+    def on_volume(self, instance, volume):
+        if self._avplayer:
+            self._avplayer.volume = float(volume)
+
+    def _get_length(self):
+        if self._avplayer:
+            return self._avplayer.duration
+        return super(SoundAvplayer, self)._get_length()
+
+
+SoundLoader.register(SoundAvplayer)
diff --git a/kivy/core/audio/audio_ffpyplayer.py b/kivy/core/audio/audio_ffpyplayer.py
new file mode 100644
index 0000000..6283aae
--- /dev/null
+++ b/kivy/core/audio/audio_ffpyplayer.py
@@ -0,0 +1,185 @@
+'''
+FFmpeg based audio player
+=========================
+
+To use, you need to install ffpyplayer and have a compiled ffmpeg shared
+library.
+
+    https://github.com/matham/ffpyplayer
+
+The docs there describe how to set this up. But briefly, first you need to
+compile ffmpeg using the shared flags while disabling the static flags (you'll
+probably have to set the fPIC flag, e.g. CFLAGS=-fPIC). Here's some
+instructions: https://trac.ffmpeg.org/wiki/CompilationGuide. For Windows, you
+can download compiled GPL binaries from http://ffmpeg.zeranoe.com/builds/.
+Similarly, you should download SDL.
+
+Now, you should a ffmpeg and sdl directory. In each, you should have a include,
+bin, and lib directory, where e.g. for Windows, lib contains the .dll.a files,
+while bin contains the actual dlls. The include directory holds the headers.
+The bin directory is only needed if the shared libraries are not already on
+the path. In the environment define FFMPEG_ROOT and SDL_ROOT, each pointing to
+the ffmpeg, and SDL directories, respectively. (If you're using SDL2,
+the include directory will contain a directory called SDL2, which then holds
+the headers).
+
+Once defined, download the ffpyplayer git and run
+
+    python setup.py build_ext --inplace
+
+Finally, before running you need to ensure that ffpyplayer is in python's path.
+
+..Note::
+
+    When kivy exits by closing the window while the audio is playing,
+    it appears that the __del__method of SoundFFPy
+    is not called. Because of this the SoundFFPy object is not
+    properly deleted when kivy exits. The consequence is that because
+    MediaPlayer creates internal threads which do not have their daemon
+    flag set, when the main threads exists it'll hang and wait for the other
+    MediaPlayer threads to exit. But since __del__ is not called to delete the
+    MediaPlayer object, those threads will remain alive hanging kivy. What this
+    means is that you have to be sure to delete the MediaPlayer object before
+    kivy exits by setting it to None.
+'''
+
+__all__ = ('SoundFFPy', )
+
+try:
+    import ffpyplayer
+    from ffpyplayer.player import MediaPlayer
+    from ffpyplayer.tools import set_log_callback, get_log_callback, formats_in
+except:
+    raise
+
+
+from kivy.clock import Clock
+from kivy.logger import Logger
+from kivy.core.audio import Sound, SoundLoader
+from kivy.weakmethod import WeakMethod
+import time
+
+try:
+    Logger.info(
+        'SoundFFPy: Using ffpyplayer {}'.format(ffpyplayer.__version__))
+except:
+    Logger.info('SoundFFPy: Using ffpyplayer {}'.format(ffpyplayer.version))
+
+
+logger_func = {'quiet': Logger.critical, 'panic': Logger.critical,
+               'fatal': Logger.critical, 'error': Logger.error,
+               'warning': Logger.warning, 'info': Logger.info,
+               'verbose': Logger.debug, 'debug': Logger.debug}
+
+
+def _log_callback(message, level):
+    message = message.strip()
+    if message:
+        logger_func[level]('ffpyplayer: {}'.format(message))
+
+
+class SoundFFPy(Sound):
+
+    @staticmethod
+    def extensions():
+        return formats_in
+
+    def __init__(self, **kwargs):
+        self._ffplayer = None
+        self.quitted = False
+        self._log_callback_set = False
+        self._state = ''
+        self.state = 'stop'
+
+        if not get_log_callback():
+            set_log_callback(_log_callback)
+            self._log_callback_set = True
+
+        super(SoundFFPy, self).__init__(**kwargs)
+
+    def __del__(self):
+        self.unload()
+        if self._log_callback_set:
+            set_log_callback(None)
+
+    def _player_callback(self, selector, value):
+        if self._ffplayer is None:
+            return
+        if selector == 'quit':
+            def close(*args):
+                self.quitted = True
+                self.unload()
+            Clock.schedule_once(close, 0)
+        elif selector == 'eof':
+            Clock.schedule_once(self._do_eos, 0)
+
+    def load(self):
+        self.unload()
+        ff_opts = {'vn': True, 'sn': True}  # only audio
+        self._ffplayer = MediaPlayer(self.source,
+                                     callback=self._player_callback,
+                                     loglevel='info', ff_opts=ff_opts)
+        player = self._ffplayer
+        player.set_volume(self.volume)
+        player.toggle_pause()
+        self._state = 'paused'
+        # wait until loaded or failed, shouldn't take long, but just to make
+        # sure metadata is available.
+        s = time.perf_counter()
+        while (player.get_metadata()['duration'] is None and
+               not self.quitted and time.perf_counter() - s < 10.):
+            time.sleep(0.005)
+
+    def unload(self):
+        if self._ffplayer:
+            self._ffplayer = None
+        self._state = ''
+        self.state = 'stop'
+        self.quitted = False
+
+    def play(self):
+        if self._state == 'playing':
+            super(SoundFFPy, self).play()
+            return
+        if not self._ffplayer:
+            self.load()
+        self._ffplayer.toggle_pause()
+        self._state = 'playing'
+        self.state = 'play'
+        super(SoundFFPy, self).play()
+        self.seek(0)
+
+    def stop(self):
+        if self._ffplayer and self._state == 'playing':
+            self._ffplayer.toggle_pause()
+            self._state = 'paused'
+            self.state = 'stop'
+        super(SoundFFPy, self).stop()
+
+    def seek(self, position):
+        if self._ffplayer is None:
+            return
+        self._ffplayer.seek(position, relative=False)
+
+    def get_pos(self):
+        if self._ffplayer is not None:
+            return self._ffplayer.get_pts()
+        return 0
+
+    def on_volume(self, instance, volume):
+        if self._ffplayer is not None:
+            self._ffplayer.set_volume(volume)
+
+    def _get_length(self):
+        if self._ffplayer is None:
+            return super(SoundFFPy, self)._get_length()
+        return self._ffplayer.get_metadata()['duration']
+
+    def _do_eos(self, *args):
+        if not self.loop:
+            self.stop()
+        else:
+            self.seek(0.)
+
+
+SoundLoader.register(SoundFFPy)
diff --git a/kivy/core/audio/audio_gstplayer.py b/kivy/core/audio/audio_gstplayer.py
new file mode 100644
index 0000000..3fd3a4d
--- /dev/null
+++ b/kivy/core/audio/audio_gstplayer.py
@@ -0,0 +1,101 @@
+'''
+Audio Gstplayer
+===============
+
+.. versionadded:: 1.8.0
+
+Implementation of a VideoBase with Kivy :class:`~kivy.lib.gstplayer.GstPlayer`
+This player is the preferred player, using Gstreamer 1.0, working on both
+Python 2 and 3.
+'''
+
+from kivy.lib.gstplayer import GstPlayer, get_gst_version
+from kivy.core.audio import Sound, SoundLoader
+from kivy.logger import Logger
+from kivy.compat import PY2
+from kivy.clock import Clock
+from os.path import realpath
+
+if PY2:
+    from urllib import pathname2url
+else:
+    from urllib.request import pathname2url
+
+Logger.info('AudioGstplayer: Using Gstreamer {}'.format(
+    '.'.join(map(str, get_gst_version()))))
+
+
+def _on_gstplayer_message(mtype, message):
+    if mtype == 'error':
+        Logger.error('AudioGstplayer: {}'.format(message))
+    elif mtype == 'warning':
+        Logger.warning('AudioGstplayer: {}'.format(message))
+    elif mtype == 'info':
+        Logger.info('AudioGstplayer: {}'.format(message))
+
+
+class SoundGstplayer(Sound):
+
+    @staticmethod
+    def extensions():
+        return ('wav', 'ogg', 'mp3', 'm4a', 'flac', 'mp4')
+
+    def __init__(self, **kwargs):
+        self.player = None
+        super(SoundGstplayer, self).__init__(**kwargs)
+
+    def _on_gst_eos_sync(self):
+        Clock.schedule_once(self._on_gst_eos, 0)
+
+    def _on_gst_eos(self, *dt):
+        if self.loop:
+            self.player.stop()
+            self.player.play()
+        else:
+            self.stop()
+
+    def load(self):
+        self.unload()
+        uri = self._get_uri()
+        self.player = GstPlayer(uri, None, self._on_gst_eos_sync,
+                                _on_gstplayer_message)
+        self.player.load()
+
+    def play(self):
+        # we need to set the volume everytime, it seems that stopping + playing
+        # the sound reset the volume.
+        self.player.set_volume(self.volume)
+        self.player.play()
+        super(SoundGstplayer, self).play()
+
+    def stop(self):
+        self.player.stop()
+        super(SoundGstplayer, self).stop()
+
+    def unload(self):
+        if self.player:
+            self.player.unload()
+            self.player = None
+
+    def seek(self, position):
+        self.player.seek(position / self.length)
+
+    def get_pos(self):
+        return self.player.get_position()
+
+    def _get_length(self):
+        return self.player.get_duration()
+
+    def on_volume(self, instance, volume):
+        self.player.set_volume(volume)
+
+    def _get_uri(self):
+        uri = self.source
+        if not uri:
+            return
+        if '://' not in uri:
+            uri = 'file:' + pathname2url(realpath(uri))
+        return uri
+
+
+SoundLoader.register(SoundGstplayer)
diff --git a/kivy/core/audio/audio_pygame.py b/kivy/core/audio/audio_pygame.py
new file mode 100644
index 0000000..fdf9c61
--- /dev/null
+++ b/kivy/core/audio/audio_pygame.py
@@ -0,0 +1,127 @@
+'''
+AudioPygame: implementation of Sound with Pygame
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('SoundPygame', )
+
+from kivy.clock import Clock
+from kivy.utils import platform, deprecated
+from kivy.core.audio import Sound, SoundLoader
+
+_platform = platform
+try:
+    if _platform == 'android':
+        try:
+            import android.mixer as mixer
+        except ImportError:
+            # old python-for-android version
+            import android_mixer as mixer
+    else:
+        from pygame import mixer
+except:
+    raise
+
+# init pygame sound
+mixer.pre_init(44100, -16, 2, 1024)
+mixer.init()
+mixer.set_num_channels(32)
+
+
+class SoundPygame(Sound):
+
+    # XXX we don't set __slots__ here, to automatically add
+    # a dictionary. We need that to be able to use weakref for
+    # SoundPygame object. Otherwise, it failed with:
+    # TypeError: cannot create weak reference to 'SoundPygame' object
+    # We use our clock in play() method.
+    # __slots__ = ('_data', '_channel')
+    _check_play_ev = None
+
+    @staticmethod
+    def extensions():
+        if _platform == 'android':
+            return ('wav', 'ogg', 'mp3', 'm4a')
+        return ('wav', 'ogg')
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, **kwargs):
+        self._data = None
+        self._channel = None
+        super(SoundPygame, self).__init__(**kwargs)
+
+    def _check_play(self, dt):
+        if self._channel is None:
+            return False
+        if self._channel.get_busy():
+            return
+        if self.loop:
+            def do_loop(dt):
+                self.play()
+            Clock.schedule_once(do_loop)
+        else:
+            self.stop()
+        return False
+
+    def play(self):
+        if not self._data:
+            return
+        self._data.set_volume(self.volume)
+        self._channel = self._data.play()
+        self.start_time = Clock.time()
+        # schedule event to check if the sound is still playing or not
+        self._check_play_ev = Clock.schedule_interval(self._check_play, 0.1)
+        super(SoundPygame, self).play()
+
+    def stop(self):
+        if not self._data:
+            return
+        self._data.stop()
+        # ensure we don't have anymore the callback
+        if self._check_play_ev is not None:
+            self._check_play_ev.cancel()
+            self._check_play_ev = None
+        self._channel = None
+        super(SoundPygame, self).stop()
+
+    def load(self):
+        self.unload()
+        if self.source is None:
+            return
+        self._data = mixer.Sound(self.source)
+
+    def unload(self):
+        self.stop()
+        self._data = None
+
+    def seek(self, position):
+        if not self._data:
+            return
+        if _platform == 'android' and self._channel:
+            self._channel.seek(position)
+
+    def get_pos(self):
+        if self._data is not None and self._channel:
+            if _platform == 'android':
+                return self._channel.get_pos()
+            return Clock.time() - self.start_time
+        return 0
+
+    def on_volume(self, instance, volume):
+        if self._data is not None:
+            self._data.set_volume(volume)
+
+    def _get_length(self):
+        if _platform == 'android' and self._channel:
+            return self._channel.get_length()
+        if self._data is not None:
+            return self._data.get_length()
+        return super(SoundPygame, self)._get_length()
+
+
+SoundLoader.register(SoundPygame)
diff --git a/kivy/core/audio/audio_sdl2.cpython-310-x86_64-linux-gnu.so b/kivy/core/audio/audio_sdl2.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..28097d9
Binary files /dev/null and b/kivy/core/audio/audio_sdl2.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/core/camera/__init__.py b/kivy/core/camera/__init__.py
new file mode 100644
index 0000000..b621b34
--- /dev/null
+++ b/kivy/core/camera/__init__.py
@@ -0,0 +1,151 @@
+'''
+Camera
+======
+
+Core class for acquiring the camera and converting its input into a
+:class:`~kivy.graphics.texture.Texture`.
+
+.. versionchanged:: 1.10.0
+    The pygst and videocapture providers have been removed.
+
+.. versionchanged:: 1.8.0
+    There is now 2 distinct Gstreamer implementation: one using Gi/Gst
+    working for both Python 2+3 with Gstreamer 1.0, and one using PyGST
+    working only for Python 2 + Gstreamer 0.10.
+'''
+
+__all__ = ('CameraBase', 'Camera')
+
+
+from kivy.utils import platform
+from kivy.event import EventDispatcher
+from kivy.logger import Logger
+from kivy.core import core_select_lib
+
+
+class CameraBase(EventDispatcher):
+    '''Abstract Camera Widget class.
+
+    Concrete camera classes must implement initialization and
+    frame capturing to a buffer that can be uploaded to the gpu.
+
+    :Parameters:
+        `index`: int
+            Source index of the camera.
+        `size`: tuple (int, int)
+            Size at which the image is drawn. If no size is specified,
+            it defaults to the resolution of the camera image.
+        `resolution`: tuple (int, int)
+            Resolution to try to request from the camera.
+            Used in the gstreamer pipeline by forcing the appsink caps
+            to this resolution. If the camera doesn't support the resolution,
+            a negotiation error might be thrown.
+
+    :Events:
+        `on_load`
+            Fired when the camera is loaded and the texture has become
+            available.
+        `on_texture`
+            Fired each time the camera texture is updated.
+    '''
+
+    __events__ = ('on_load', 'on_texture')
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault('stopped', False)
+        kwargs.setdefault('resolution', (640, 480))
+        kwargs.setdefault('index', 0)
+
+        self.stopped = kwargs.get('stopped')
+        self._resolution = kwargs.get('resolution')
+        self._index = kwargs.get('index')
+        self._buffer = None
+        self._format = 'rgb'
+        self._texture = None
+        self.capture_device = None
+        kwargs.setdefault('size', self._resolution)
+
+        super(CameraBase, self).__init__()
+
+        self.init_camera()
+
+        if not self.stopped:
+            self.start()
+
+    def _set_resolution(self, res):
+        self._resolution = res
+        self.init_camera()
+
+    def _get_resolution(self):
+        return self._resolution
+
+    resolution = property(lambda self: self._get_resolution(),
+                          lambda self, x: self._set_resolution(x),
+                          doc='Resolution of camera capture (width, height)')
+
+    def _set_index(self, x):
+        if x == self._index:
+            return
+        self._index = x
+        self.init_camera()
+
+    def _get_index(self):
+        return self._x
+
+    index = property(lambda self: self._get_index(),
+                     lambda self, x: self._set_index(x),
+                     doc='Source index of the camera')
+
+    def _get_texture(self):
+        return self._texture
+    texture = property(lambda self: self._get_texture(),
+                       doc='Return the camera texture with the latest capture')
+
+    def init_camera(self):
+        '''Initialise the camera (internal)'''
+        pass
+
+    def start(self):
+        '''Start the camera acquire'''
+        self.stopped = False
+
+    def stop(self):
+        '''Release the camera'''
+        self.stopped = True
+
+    def _update(self, dt):
+        '''Update the camera (internal)'''
+        pass
+
+    def _copy_to_gpu(self):
+        '''Copy the the buffer into the texture'''
+        if self._texture is None:
+            Logger.debug('Camera: copy_to_gpu() failed, _texture is None !')
+            return
+        self._texture.blit_buffer(self._buffer, colorfmt=self._format)
+        self._buffer = None
+        self.dispatch('on_texture')
+
+    def on_texture(self):
+        pass
+
+    def on_load(self):
+        pass
+
+
+# Load the appropriate providers
+providers = ()
+
+if platform in ['macosx', 'ios']:
+    providers += (('avfoundation', 'camera_avfoundation',
+                   'CameraAVFoundation'), )
+elif platform == 'android':
+    providers += (('android', 'camera_android', 'CameraAndroid'), )
+else:
+    providers += (('picamera', 'camera_picamera', 'CameraPiCamera'), )
+    providers += (('gi', 'camera_gi', 'CameraGi'), )
+
+providers += (('opencv', 'camera_opencv', 'CameraOpenCV'), )
+
+
+Camera = core_select_lib('camera', (providers))
diff --git a/kivy/core/camera/__pycache__/__init__.cpython-310.pyc b/kivy/core/camera/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..7f82c2e
Binary files /dev/null and b/kivy/core/camera/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/camera/__pycache__/camera_android.cpython-310.pyc b/kivy/core/camera/__pycache__/camera_android.cpython-310.pyc
new file mode 100644
index 0000000..00b9016
Binary files /dev/null and b/kivy/core/camera/__pycache__/camera_android.cpython-310.pyc differ
diff --git a/kivy/core/camera/__pycache__/camera_gi.cpython-310.pyc b/kivy/core/camera/__pycache__/camera_gi.cpython-310.pyc
new file mode 100644
index 0000000..5056187
Binary files /dev/null and b/kivy/core/camera/__pycache__/camera_gi.cpython-310.pyc differ
diff --git a/kivy/core/camera/__pycache__/camera_opencv.cpython-310.pyc b/kivy/core/camera/__pycache__/camera_opencv.cpython-310.pyc
new file mode 100644
index 0000000..d3b989b
Binary files /dev/null and b/kivy/core/camera/__pycache__/camera_opencv.cpython-310.pyc differ
diff --git a/kivy/core/camera/__pycache__/camera_picamera.cpython-310.pyc b/kivy/core/camera/__pycache__/camera_picamera.cpython-310.pyc
new file mode 100644
index 0000000..5f169c3
Binary files /dev/null and b/kivy/core/camera/__pycache__/camera_picamera.cpython-310.pyc differ
diff --git a/kivy/core/camera/camera_android.py b/kivy/core/camera/camera_android.py
new file mode 100644
index 0000000..66f5b8d
--- /dev/null
+++ b/kivy/core/camera/camera_android.py
@@ -0,0 +1,206 @@
+from jnius import autoclass, PythonJavaClass, java_method
+from kivy.clock import Clock
+from kivy.graphics.texture import Texture
+from kivy.graphics import Fbo, Callback, Rectangle
+from kivy.core.camera import CameraBase
+import threading
+
+
+Camera = autoclass('android.hardware.Camera')
+SurfaceTexture = autoclass('android.graphics.SurfaceTexture')
+GL_TEXTURE_EXTERNAL_OES = autoclass(
+    'android.opengl.GLES11Ext').GL_TEXTURE_EXTERNAL_OES
+ImageFormat = autoclass('android.graphics.ImageFormat')
+
+
+class PreviewCallback(PythonJavaClass):
+    """
+    Interface used to get back the preview frame of the Android Camera
+    """
+    __javainterfaces__ = ('android.hardware.Camera$PreviewCallback', )
+
+    def __init__(self, callback):
+        super(PreviewCallback, self).__init__()
+        self._callback = callback
+
+    @java_method('([BLandroid/hardware/Camera;)V')
+    def onPreviewFrame(self, data, camera):
+        self._callback(data, camera)
+
+
+class CameraAndroid(CameraBase):
+    """
+    Implementation of CameraBase using Android API
+    """
+
+    _update_ev = None
+
+    def __init__(self, **kwargs):
+        self._android_camera = None
+        self._preview_cb = PreviewCallback(self._on_preview_frame)
+        self._buflock = threading.Lock()
+        super(CameraAndroid, self).__init__(**kwargs)
+
+    def __del__(self):
+        self._release_camera()
+
+    def init_camera(self):
+        self._release_camera()
+        self._android_camera = Camera.open(self._index)
+        params = self._android_camera.getParameters()
+        width, height = self._resolution
+        params.setPreviewSize(width, height)
+        supported_focus_modes = self._android_camera.getParameters() \
+            .getSupportedFocusModes()
+        if supported_focus_modes.contains('continuous-picture'):
+            params.setFocusMode('continuous-picture')
+        self._android_camera.setParameters(params)
+        # self._android_camera.setDisplayOrientation()
+        self.fps = 30.
+
+        pf = params.getPreviewFormat()
+        assert(pf == ImageFormat.NV21)  # default format is NV21
+        self._bufsize = int(ImageFormat.getBitsPerPixel(pf) / 8. *
+                            width * height)
+
+        self._camera_texture = Texture(width=width, height=height,
+                                       target=GL_TEXTURE_EXTERNAL_OES,
+                                       colorfmt='rgba')
+        self._surface_texture = SurfaceTexture(int(self._camera_texture.id))
+        self._android_camera.setPreviewTexture(self._surface_texture)
+
+        self._fbo = Fbo(size=self._resolution)
+        self._fbo['resolution'] = (float(width), float(height))
+        self._fbo.shader.fs = '''
+            #extension GL_OES_EGL_image_external : require
+            #ifdef GL_ES
+                precision highp float;
+            #endif
+
+            /* Outputs from the vertex shader */
+            varying vec4 frag_color;
+            varying vec2 tex_coord0;
+
+            /* uniform texture samplers */
+            uniform sampler2D texture0;
+            uniform samplerExternalOES texture1;
+            uniform vec2 resolution;
+
+            void main()
+            {
+                vec2 coord = vec2(tex_coord0.y * (
+                    resolution.y / resolution.x), 1. -tex_coord0.x);
+                gl_FragColor = texture2D(texture1, tex_coord0);
+            }
+        '''
+        with self._fbo:
+            self._texture_cb = Callback(lambda instr:
+                                        self._camera_texture.bind)
+            Rectangle(size=self._resolution)
+
+    def _release_camera(self):
+        if self._android_camera is None:
+            return
+
+        self.stop()
+        self._android_camera.release()
+        self._android_camera = None
+
+        # clear texture and it'll be reset in `_update` pointing to new FBO
+        self._texture = None
+        del self._fbo, self._surface_texture, self._camera_texture
+
+    def _on_preview_frame(self, data, camera):
+        with self._buflock:
+            if self._buffer is not None:
+                # add buffer back for reuse
+                self._android_camera.addCallbackBuffer(self._buffer)
+            self._buffer = data
+        # check if frame grabbing works
+        # print self._buffer, len(self.frame_data)
+
+    def _refresh_fbo(self):
+        self._texture_cb.ask_update()
+        self._fbo.draw()
+
+    def start(self):
+        super(CameraAndroid, self).start()
+
+        with self._buflock:
+            self._buffer = None
+        for k in range(2):  # double buffer
+            buf = b'\x00' * self._bufsize
+            self._android_camera.addCallbackBuffer(buf)
+        self._android_camera.setPreviewCallbackWithBuffer(self._preview_cb)
+
+        self._android_camera.startPreview()
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+        self._update_ev = Clock.schedule_interval(self._update, 1 / self.fps)
+
+    def stop(self):
+        super(CameraAndroid, self).stop()
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+            self._update_ev = None
+        self._android_camera.stopPreview()
+
+        self._android_camera.setPreviewCallbackWithBuffer(None)
+        # buffer queue cleared as well, to be recreated on next start
+        with self._buflock:
+            self._buffer = None
+
+    def _update(self, dt):
+        self._surface_texture.updateTexImage()
+        self._refresh_fbo()
+        if self._texture is None:
+            self._texture = self._fbo.texture
+            self.dispatch('on_load')
+        self._copy_to_gpu()
+
+    def _copy_to_gpu(self):
+        """
+        A dummy placeholder (the image is already in GPU) to be consistent
+        with other providers.
+        """
+        self.dispatch('on_texture')
+
+    def grab_frame(self):
+        """
+        Grab current frame (thread-safe, minimal overhead)
+        """
+        with self._buflock:
+            if self._buffer is None:
+                return None
+            buf = self._buffer.tostring()
+            return buf
+
+    def decode_frame(self, buf):
+        """
+        Decode image data from grabbed frame.
+
+        This method depends on OpenCV and NumPy - however it is only used for
+        fetching the current frame as a NumPy array, and not required when
+        this :class:`CameraAndroid` provider is simply used by a
+        :class:`~kivy.uix.camera.Camera` widget.
+        """
+        import numpy as np
+        from cv2 import cvtColor
+
+        w, h = self._resolution
+        arr = np.fromstring(buf, 'uint8').reshape((h + h / 2, w))
+        arr = cvtColor(arr, 93)  # NV21 -> BGR
+        return arr
+
+    def read_frame(self):
+        """
+        Grab and decode frame in one call
+        """
+        return self.decode_frame(self.grab_frame())
+
+    @staticmethod
+    def get_camera_count():
+        """
+        Get the number of available cameras.
+        """
+        return Camera.getNumberOfCameras()
diff --git a/kivy/core/camera/camera_gi.py b/kivy/core/camera/camera_gi.py
new file mode 100644
index 0000000..f9f4fe6
--- /dev/null
+++ b/kivy/core/camera/camera_gi.py
@@ -0,0 +1,170 @@
+'''
+Gi Camera
+=========
+
+Implement CameraBase with Gi / Gstreamer, working on both Python 2 and 3
+'''
+
+__all__ = ('CameraGi', )
+
+from gi.repository import Gst
+from kivy.clock import Clock
+from kivy.graphics.texture import Texture
+from kivy.core.camera import CameraBase
+from kivy.support import install_gobject_iteration
+from kivy.logger import Logger
+from ctypes import Structure, c_void_p, c_int, string_at
+from weakref import ref
+import atexit
+
+# initialize the camera/gi. if the older version is used, don't use camera_gi.
+Gst.init(None)
+version = Gst.version()
+if version < (1, 0, 0, 0):
+    raise Exception('Cannot use camera_gi, Gstreamer < 1.0 is not supported.')
+Logger.info('CameraGi: Using Gstreamer {}'.format(
+    '.'.join(['{}'.format(x) for x in Gst.version()])))
+install_gobject_iteration()
+
+
+class _MapInfo(Structure):
+    _fields_ = [
+        ('memory', c_void_p),
+        ('flags', c_int),
+        ('data', c_void_p)]
+    # we don't care about the rest
+
+
+def _on_cameragi_unref(obj):
+    if obj in CameraGi._instances:
+        CameraGi._instances.remove(obj)
+
+
+class CameraGi(CameraBase):
+    '''Implementation of CameraBase using GStreamer
+
+    :Parameters:
+        `video_src`: str, default is 'v4l2src'
+            Other tested options are: 'dc1394src' for firewire
+            dc camera (e.g. firefly MV). Any gstreamer video source
+            should potentially work.
+            Theoretically a longer string using "!" can be used
+            describing the first part of a gstreamer pipeline.
+    '''
+
+    _instances = []
+
+    def __init__(self, **kwargs):
+        self._pipeline = None
+        self._camerasink = None
+        self._decodebin = None
+        self._texturesize = None
+        self._video_src = kwargs.get('video_src', 'v4l2src')
+        wk = ref(self, _on_cameragi_unref)
+        CameraGi._instances.append(wk)
+        super(CameraGi, self).__init__(**kwargs)
+
+    def init_camera(self):
+        # TODO: This doesn't work when camera resolution is resized at runtime.
+        # There must be some other way to release the camera?
+        if self._pipeline:
+            self._pipeline = None
+
+        video_src = self._video_src
+        if video_src == 'v4l2src':
+            video_src += ' device=/dev/video%d' % self._index
+        elif video_src == 'dc1394src':
+            video_src += ' camera-number=%d' % self._index
+
+        if Gst.version() < (1, 0, 0, 0):
+            caps = ('video/x-raw-rgb,red_mask=(int)0xff0000,'
+                    'green_mask=(int)0x00ff00,blue_mask=(int)0x0000ff')
+            pl = ('{} ! decodebin name=decoder ! ffmpegcolorspace ! '
+                  'appsink name=camerasink emit-signals=True caps={}')
+        else:
+            caps = 'video/x-raw,format=RGB'
+            pl = '{} ! decodebin name=decoder ! videoconvert ! appsink ' + \
+                 'name=camerasink emit-signals=True caps={}'
+
+        self._pipeline = Gst.parse_launch(pl.format(video_src, caps))
+        self._camerasink = self._pipeline.get_by_name('camerasink')
+        self._camerasink.connect('new-sample', self._gst_new_sample)
+        self._decodebin = self._pipeline.get_by_name('decoder')
+
+        if self._camerasink and not self.stopped:
+            self.start()
+
+    def _gst_new_sample(self, *largs):
+        sample = self._camerasink.emit('pull-sample')
+        if sample is None:
+            return False
+
+        self._sample = sample
+
+        if self._texturesize is None:
+            # try to get the camera image size
+            for pad in self._decodebin.srcpads:
+                s = pad.get_current_caps().get_structure(0)
+                self._texturesize = (
+                    s.get_value('width'),
+                    s.get_value('height'))
+                Clock.schedule_once(self._update)
+                return False
+
+        Clock.schedule_once(self._update)
+        return False
+
+    def start(self):
+        super(CameraGi, self).start()
+        self._pipeline.set_state(Gst.State.PLAYING)
+
+    def stop(self):
+        super(CameraGi, self).stop()
+        self._pipeline.set_state(Gst.State.PAUSED)
+
+    def unload(self):
+        self._pipeline.set_state(Gst.State.NULL)
+
+    def _update(self, dt):
+        sample, self._sample = self._sample, None
+        if sample is None:
+            return
+
+        if self._texture is None and self._texturesize is not None:
+            self._texture = Texture.create(
+                size=self._texturesize, colorfmt='rgb')
+            self._texture.flip_vertical()
+            self.dispatch('on_load')
+
+        # decode sample
+        # read the data from the buffer memory
+        try:
+            buf = sample.get_buffer()
+            result, mapinfo = buf.map(Gst.MapFlags.READ)
+
+            # We cannot get the data out of mapinfo, using Gst 1.0.6 + Gi 3.8.0
+            # related bug report:
+            # https://bugzilla.gnome.org/show_bug.cgi?id=6t8663
+            # ie: mapinfo.data is normally a char*, but here, we have an int
+            # So right now, we use ctypes instead to read the mapinfo ourself.
+            addr = mapinfo.__hash__()
+            c_mapinfo = _MapInfo.from_address(addr)
+
+            # now get the memory
+            self._buffer = string_at(c_mapinfo.data, mapinfo.size)
+            self._copy_to_gpu()
+        finally:
+            if mapinfo is not None:
+                buf.unmap(mapinfo)
+
+
+@atexit.register
+def camera_gi_clean():
+    # if we leave the python process with some video running, we can hit a
+    # segfault. This is forcing the stop/unload of all remaining videos before
+    # exiting the python process.
+    for weakcamera in CameraGi._instances:
+        camera = weakcamera()
+        if isinstance(camera, CameraGi):
+            camera.stop()
+            camera.unload()
diff --git a/kivy/core/camera/camera_opencv.py b/kivy/core/camera/camera_opencv.py
new file mode 100644
index 0000000..f24a520
--- /dev/null
+++ b/kivy/core/camera/camera_opencv.py
@@ -0,0 +1,163 @@
+'''
+OpenCV Camera: Implement CameraBase with OpenCV
+'''
+
+#
+# TODO: make usage of thread or multiprocess
+#
+
+from __future__ import division
+
+__all__ = ('CameraOpenCV')
+
+
+from kivy.logger import Logger
+from kivy.clock import Clock
+from kivy.graphics.texture import Texture
+from kivy.core.camera import CameraBase
+
+try:
+    # opencv 1 case
+    import opencv as cv
+
+    try:
+        import opencv.highgui as hg
+    except ImportError:
+        class Hg(object):
+            '''
+            On OSX, not only are the import names different,
+            but the API also differs.
+            There is no module called 'highgui' but the names are
+            directly available in the 'cv' module.
+            Some of them even have a different names.
+
+            Therefore we use this proxy object.
+            '''
+
+            def __getattr__(self, attr):
+                if attr.startswith('cv'):
+                    attr = attr[2:]
+                got = getattr(cv, attr)
+                return got
+
+        hg = Hg()
+
+except ImportError:
+    # opencv 2 case (and also opencv 3, because it still uses cv2 module name)
+    try:
+        import cv2
+        # here missing this OSX specific highgui thing.
+        # I'm not on OSX so don't know if it is still valid in opencv >= 2
+    except ImportError:
+        raise
+
+
+class CameraOpenCV(CameraBase):
+    '''
+    Implementation of CameraBase using OpenCV
+    '''
+    _update_ev = None
+
+    def __init__(self, **kwargs):
+        # we will need it, because constants have
+        # different access paths between ver. 2 and 3
+        try:
+            self.opencvMajorVersion = int(cv.__version__[0])
+        except NameError:
+            self.opencvMajorVersion = int(cv2.__version__[0])
+
+        self._device = None
+        super(CameraOpenCV, self).__init__(**kwargs)
+
+    def init_camera(self):
+        # consts have changed locations between versions 2 and 3
+        if self.opencvMajorVersion in (3, 4):
+            PROPERTY_WIDTH = cv2.CAP_PROP_FRAME_WIDTH
+            PROPERTY_HEIGHT = cv2.CAP_PROP_FRAME_HEIGHT
+            PROPERTY_FPS = cv2.CAP_PROP_FPS
+        elif self.opencvMajorVersion == 2:
+            PROPERTY_WIDTH = cv2.cv.CV_CAP_PROP_FRAME_WIDTH
+            PROPERTY_HEIGHT = cv2.cv.CV_CAP_PROP_FRAME_HEIGHT
+            PROPERTY_FPS = cv2.cv.CV_CAP_PROP_FPS
+        elif self.opencvMajorVersion == 1:
+            PROPERTY_WIDTH = cv.CV_CAP_PROP_FRAME_WIDTH
+            PROPERTY_HEIGHT = cv.CV_CAP_PROP_FRAME_HEIGHT
+            PROPERTY_FPS = cv.CV_CAP_PROP_FPS
+
+        Logger.debug('Using opencv ver.' + str(self.opencvMajorVersion))
+
+        if self.opencvMajorVersion == 1:
+            # create the device
+            self._device = hg.cvCreateCameraCapture(self._index)
+            # Set preferred resolution
+            cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_WIDTH,
+                                  self.resolution[0])
+            cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_HEIGHT,
+                                  self.resolution[1])
+            # and get frame to check if it's ok
+            frame = hg.cvQueryFrame(self._device)
+            # Just set the resolution to the frame we just got, but don't use
+            # self.resolution for that as that would cause an infinite
+            # recursion with self.init_camera (but slowly as we'd have to
+            # always get a frame).
+            self._resolution = (int(frame.width), int(frame.height))
+            # get fps
+            self.fps = cv.GetCaptureProperty(self._device, cv.CV_CAP_PROP_FPS)
+
+        elif self.opencvMajorVersion in (2, 3, 4):
+            # create the device
+            self._device = cv2.VideoCapture(self._index)
+            # Set preferred resolution
+            self._device.set(PROPERTY_WIDTH,
+                             self.resolution[0])
+            self._device.set(PROPERTY_HEIGHT,
+                             self.resolution[1])
+            # and get frame to check if it's ok
+            ret, frame = self._device.read()
+
+            # source:
+            # http://stackoverflow.com/questions/32468371/video-capture-propid-parameters-in-opencv # noqa
+            self._resolution = (int(frame.shape[1]), int(frame.shape[0]))
+            # get fps
+            self.fps = self._device.get(PROPERTY_FPS)
+
+        if self.fps == 0 or self.fps == 1:
+            self.fps = 1.0 / 30
+        elif self.fps > 1:
+            self.fps = 1.0 / self.fps
+
+        if not self.stopped:
+            self.start()
+
+    def _update(self, dt):
+        if self.stopped:
+            return
+        if self._texture is None:
+            # Create the texture
+            self._texture = Texture.create(self._resolution)
+            self._texture.flip_vertical()
+            self.dispatch('on_load')
+        try:
+            ret, frame = self._device.read()
+            self._format = 'bgr'
+            try:
+                self._buffer = frame.imageData
+            except AttributeError:
+                # frame is already of type ndarray
+                # which can be reshaped to 1-d.
+                self._buffer = frame.reshape(-1)
+            self._copy_to_gpu()
+        except:
+            Logger.exception('OpenCV: Couldn\'t get image from Camera')
+
+    def start(self):
+        super(CameraOpenCV, self).start()
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+        self._update_ev = Clock.schedule_interval(self._update, self.fps)
+
+    def stop(self):
+        super(CameraOpenCV, self).stop()
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+            self._update_ev = None
diff --git a/kivy/core/camera/camera_picamera.py b/kivy/core/camera/camera_picamera.py
new file mode 100644
index 0000000..98c5e95
--- /dev/null
+++ b/kivy/core/camera/camera_picamera.py
@@ -0,0 +1,96 @@
+'''
+PiCamera Camera: Implement CameraBase with PiCamera
+'''
+
+#
+# TODO: make usage of thread or multiprocess
+#
+
+__all__ = ('CameraPiCamera', )
+
+from math import ceil
+
+from kivy.logger import Logger
+from kivy.clock import Clock
+from kivy.graphics.texture import Texture
+from kivy.core.camera import CameraBase
+
+from picamera import PiCamera
+import numpy
+
+
+class CameraPiCamera(CameraBase):
+    '''Implementation of CameraBase using PiCamera
+    '''
+    _update_ev = None
+
+    def __init__(self, **kwargs):
+        self._camera = None
+        self._format = 'bgr'
+        self._framerate = kwargs.get('framerate', 30)
+        super(CameraPiCamera, self).__init__(**kwargs)
+
+    def init_camera(self):
+        if self._camera is not None:
+            self._camera.close()
+
+        self._camera = PiCamera()
+        self._camera.resolution = self.resolution
+        self._camera.framerate = self._framerate
+        self._camera.iso = 800
+
+        self.fps = 1. / self._framerate
+
+        if not self.stopped:
+            self.start()
+
+    def raw_buffer_size(self):
+        '''Round buffer size up to 32x16 blocks.
+
+        See https://picamera.readthedocs.io/en/release-1.13/recipes2.html#capturing-to-a-numpy-array
+        '''  # noqa
+        return (
+            ceil(self.resolution[0] / 32.) * 32,
+            ceil(self.resolution[1] / 16.) * 16
+        )
+
+    def _update(self, dt):
+        if self.stopped:
+            return
+
+        if self._texture is None:
+            # Create the texture
+            self._texture = Texture.create(self._resolution)
+            self._texture.flip_vertical()
+            self.dispatch('on_load')
+
+        try:
+            bufsize = self.raw_buffer_size()
+            output = numpy.empty(
+                (bufsize[0] * bufsize[1] * 3,), dtype=numpy.uint8)
+            self._camera.capture(output, self._format, use_video_port=True)
+
+            # Trim the buffer to fit the actual requested resolution.
+            # TODO: Is there a simpler way to do all this reshuffling?
+            output = output.reshape((bufsize[0], bufsize[1], 3))
+            output = output[:self.resolution[0], :self.resolution[1], :]
+            self._buffer = output.reshape(
+                (self.resolution[0] * self.resolution[1] * 3,))
+
+            self._copy_to_gpu()
+        except KeyboardInterrupt:
+            raise
+        except Exception:
+            Logger.exception('PiCamera: Couldn\'t get image from Camera')
+
+    def start(self):
+        super(CameraPiCamera, self).start()
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+        self._update_ev = Clock.schedule_interval(self._update, self.fps)
+
+    def stop(self):
+        super(CameraPiCamera, self).stop()
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+            self._update_ev = None
diff --git a/kivy/core/clipboard/__init__.py b/kivy/core/clipboard/__init__.py
new file mode 100644
index 0000000..2fe4a9e
--- /dev/null
+++ b/kivy/core/clipboard/__init__.py
@@ -0,0 +1,157 @@
+'''
+Clipboard
+=========
+
+Core class for accessing the Clipboard. If we are not able to access the
+system clipboard, a fake one will be used.
+
+Usage example:
+
+.. code-block:: kv
+
+    #:import Clipboard kivy.core.clipboard.Clipboard
+
+    Button:
+        on_release:
+            self.text = Clipboard.paste()
+            Clipboard.copy('Data')
+'''
+
+__all__ = ('ClipboardBase', 'Clipboard')
+
+from kivy import Logger
+from kivy.core import core_select_lib
+from kivy.utils import platform
+from kivy.setupconfig import USE_SDL2
+
+
+class ClipboardBase(object):
+
+    def get(self, mimetype):
+        '''Get the current data in clipboard, using the mimetype if possible.
+        You not use this method directly. Use :meth:`paste` instead.
+        '''
+        pass
+
+    def put(self, data, mimetype):
+        '''Put data on the clipboard, and attach a mimetype.
+        You should not use this method directly. Use :meth:`copy` instead.
+        '''
+        pass
+
+    def get_types(self):
+        '''Return a list of supported mimetypes
+        '''
+        return []
+
+    def _ensure_clipboard(self):
+        ''' Ensure that the clipboard has been properly initialised.
+        '''
+
+        if hasattr(self, '_clip_mime_type'):
+            return
+
+        if platform == 'win':
+            self._clip_mime_type = 'text/plain;charset=utf-8'
+            # windows clipboard uses a utf-16 little endian encoding
+            self._encoding = 'utf-16-le'
+        elif platform == 'linux':
+            self._clip_mime_type = 'text/plain;charset=utf-8'
+            self._encoding = 'utf-8'
+        else:
+            self._clip_mime_type = 'text/plain'
+            self._encoding = 'utf-8'
+
+    def copy(self, data=''):
+        ''' Copy the value provided in argument `data` into current clipboard.
+        If data is not of type string it will be converted to string.
+
+        .. versionadded:: 1.9.0
+
+        '''
+        if data:
+            self._copy(data)
+
+    def paste(self):
+        ''' Get text from the system clipboard and return it a usable string.
+
+        .. versionadded:: 1.9.0
+
+        '''
+        return self._paste()
+
+    def _copy(self, data):
+        self._ensure_clipboard()
+        if not isinstance(data, bytes):
+            data = data.encode(self._encoding)
+        self.put(data, self._clip_mime_type)
+
+    def _paste(self):
+        self._ensure_clipboard()
+        _clip_types = Clipboard.get_types()
+
+        mime_type = self._clip_mime_type
+        if mime_type not in _clip_types:
+            mime_type = 'text/plain'
+
+        data = self.get(mime_type)
+        if data is not None:
+            # decode only if we don't have unicode
+            # we would still need to decode from utf-16 (windows)
+            # data is of type bytes in PY3
+            if isinstance(data, bytes):
+                data = data.decode(self._encoding, 'ignore')
+            # remove null strings mostly a windows issue
+            data = data.replace(u'\x00', u'')
+            return data
+        return u''
+
+
+# load clipboard implementation
+_clipboards = []
+if platform == 'android':
+    _clipboards.append(
+        ('android', 'clipboard_android', 'ClipboardAndroid'))
+elif platform == 'macosx':
+    _clipboards.append(
+        ('nspaste', 'clipboard_nspaste', 'ClipboardNSPaste'))
+elif platform == 'win':
+    _clipboards.append(
+        ('winctypes', 'clipboard_winctypes', 'ClipboardWindows'))
+elif platform == 'linux':
+    _clipboards.append(
+        ('xclip', 'clipboard_xclip', 'ClipboardXclip'))
+    _clipboards.append(
+        ('xsel', 'clipboard_xsel', 'ClipboardXsel'))
+    _clipboards.append(
+        ('dbusklipper', 'clipboard_dbusklipper', 'ClipboardDbusKlipper'))
+    _clipboards.append(
+        ('gtk3', 'clipboard_gtk3', 'ClipboardGtk3'))
+
+if USE_SDL2:
+    _clipboards.append(
+        ('sdl2', 'clipboard_sdl2', 'ClipboardSDL2'))
+else:
+    _clipboards.append(
+        ('pygame', 'clipboard_pygame', 'ClipboardPygame'))
+
+_clipboards.append(
+    ('dummy', 'clipboard_dummy', 'ClipboardDummy'))
+
+Clipboard = core_select_lib('clipboard', _clipboards, True)
+CutBuffer = None
+
+if platform == 'linux':
+    _cutbuffers = [
+        ('xclip', 'clipboard_xclip', 'ClipboardXclip'),
+        ('xsel', 'clipboard_xsel', 'ClipboardXsel'),
+    ]
+
+    if Clipboard.__class__.__name__ in (c[2] for c in _cutbuffers):
+        CutBuffer = Clipboard
+    else:
+        CutBuffer = core_select_lib('cutbuffer', _cutbuffers, True,
+                                    basemodule='clipboard')
+
+    if CutBuffer:
+        Logger.info('CutBuffer: cut buffer support enabled')
diff --git a/kivy/core/clipboard/__pycache__/__init__.cpython-310.pyc b/kivy/core/clipboard/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..def6fec
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/_clipboard_ext.cpython-310.pyc b/kivy/core/clipboard/__pycache__/_clipboard_ext.cpython-310.pyc
new file mode 100644
index 0000000..4da6e6c
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/_clipboard_ext.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_android.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_android.cpython-310.pyc
new file mode 100644
index 0000000..98ac9f3
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_android.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_dbusklipper.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_dbusklipper.cpython-310.pyc
new file mode 100644
index 0000000..84502e3
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_dbusklipper.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_dummy.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_dummy.cpython-310.pyc
new file mode 100644
index 0000000..555abad
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_dummy.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_gtk3.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_gtk3.cpython-310.pyc
new file mode 100644
index 0000000..a9472f4
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_gtk3.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_nspaste.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_nspaste.cpython-310.pyc
new file mode 100644
index 0000000..c66f718
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_nspaste.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_pygame.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_pygame.cpython-310.pyc
new file mode 100644
index 0000000..a56949c
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_pygame.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_sdl2.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_sdl2.cpython-310.pyc
new file mode 100644
index 0000000..bc381fb
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_sdl2.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_winctypes.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_winctypes.cpython-310.pyc
new file mode 100644
index 0000000..f0bebfd
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_winctypes.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_xclip.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_xclip.cpython-310.pyc
new file mode 100644
index 0000000..a25a453
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_xclip.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/__pycache__/clipboard_xsel.cpython-310.pyc b/kivy/core/clipboard/__pycache__/clipboard_xsel.cpython-310.pyc
new file mode 100644
index 0000000..f6786db
Binary files /dev/null and b/kivy/core/clipboard/__pycache__/clipboard_xsel.cpython-310.pyc differ
diff --git a/kivy/core/clipboard/_clipboard_ext.py b/kivy/core/clipboard/_clipboard_ext.py
new file mode 100644
index 0000000..a27991d
--- /dev/null
+++ b/kivy/core/clipboard/_clipboard_ext.py
@@ -0,0 +1,36 @@
+'''
+Clipboard ext: base class for external command clipboards
+'''
+
+__all__ = ('ClipboardExternalBase', )
+
+from kivy.core.clipboard import ClipboardBase
+
+
+class ClipboardExternalBase(ClipboardBase):
+    @staticmethod
+    def _clip(inout, selection):
+        raise NotImplementedError('clip method not implemented')
+
+    def get(self, mimetype='text/plain'):
+        p = self._clip('out', 'clipboard')
+        data, _ = p.communicate()
+        return data
+
+    def put(self, data, mimetype='text/plain'):
+        p = self._clip('in', 'clipboard')
+        p.communicate(data)
+
+    def get_cutbuffer(self):
+        p = self._clip('out', 'primary')
+        data, _ = p.communicate()
+        return data.decode('utf8')
+
+    def set_cutbuffer(self, data):
+        if not isinstance(data, bytes):
+            data = data.encode('utf8')
+        p = self._clip('in', 'primary')
+        p.communicate(data)
+
+    def get_types(self):
+        return [u'text/plain']
diff --git a/kivy/core/clipboard/_clipboard_sdl2.cpython-310-x86_64-linux-gnu.so b/kivy/core/clipboard/_clipboard_sdl2.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..7e82242
Binary files /dev/null and b/kivy/core/clipboard/_clipboard_sdl2.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/core/clipboard/clipboard_android.py b/kivy/core/clipboard/clipboard_android.py
new file mode 100644
index 0000000..426a4ca
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_android.py
@@ -0,0 +1,91 @@
+'''
+Clipboard Android
+=================
+
+Android implementation of Clipboard provider, using Pyjnius.
+'''
+
+__all__ = ('ClipboardAndroid', )
+
+from kivy import Logger
+from kivy.core.clipboard import ClipboardBase
+from jnius import autoclass, cast
+from android.runnable import run_on_ui_thread
+from android import python_act
+
+AndroidString = autoclass('java.lang.String')
+PythonActivity = python_act
+Context = autoclass('android.content.Context')
+VER = autoclass('android.os.Build$VERSION')
+sdk = VER.SDK_INT
+
+
+class ClipboardAndroid(ClipboardBase):
+
+    def __init__(self):
+        super(ClipboardAndroid, self).__init__()
+        self._clipboard = None
+        self._data = dict()
+        self._data['text/plain'] = None
+        self._data['application/data'] = None
+        PythonActivity._clipboard = None
+
+    def get(self, mimetype='text/plain'):
+        return self._get(mimetype).encode('utf-8')
+
+    def put(self, data, mimetype='text/plain'):
+        self._set(data, mimetype)
+
+    def get_types(self):
+        return list(self._data.keys())
+
+    @run_on_ui_thread
+    def _initialize_clipboard(self):
+        PythonActivity._clipboard = cast(
+            'android.app.Activity',
+            PythonActivity.mActivity).getSystemService(
+                                        Context.CLIPBOARD_SERVICE)
+
+    def _get_clipboard(f):
+        def called(*args, **kargs):
+            self = args[0]
+            if not PythonActivity._clipboard:
+                self._initialize_clipboard()
+                import time
+                while not PythonActivity._clipboard:
+                    time.sleep(.01)
+            return f(*args, **kargs)
+        return called
+
+    @_get_clipboard
+    def _get(self, mimetype='text/plain'):
+        clippy = PythonActivity._clipboard
+        data = ''
+        if sdk < 11:
+            data = clippy.getText()
+        else:
+            ClipDescription = autoclass('android.content.ClipDescription')
+            primary_clip = clippy.getPrimaryClip()
+            if primary_clip:
+                try:
+                    data = primary_clip.getItemAt(0)
+                    if data:
+                        data = data.coerceToText(
+                            PythonActivity.mActivity.getApplicationContext())
+                except Exception:
+                    Logger.exception('Clipboard: failed to paste')
+        return data
+
+    @_get_clipboard
+    def _set(self, data, mimetype):
+        clippy = PythonActivity._clipboard
+
+        if sdk < 11:
+            # versions previous to honeycomb
+            clippy.setText(AndroidString(data))
+        else:
+            ClipData = autoclass('android.content.ClipData')
+            new_clip = ClipData.newPlainText(AndroidString(""),
+                                         AndroidString(data))
+            # put text data onto clipboard
+            clippy.setPrimaryClip(new_clip)
diff --git a/kivy/core/clipboard/clipboard_dbusklipper.py b/kivy/core/clipboard/clipboard_dbusklipper.py
new file mode 100644
index 0000000..84c5099
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_dbusklipper.py
@@ -0,0 +1,41 @@
+'''
+Clipboard Dbus: an implementation of the Clipboard using dbus and klipper.
+'''
+
+__all__ = ('ClipboardDbusKlipper', )
+
+from kivy.utils import platform
+from kivy.core.clipboard import ClipboardBase
+
+if platform != 'linux':
+    raise SystemError('unsupported platform for dbus kde clipboard')
+
+try:
+    import dbus
+    bus = dbus.SessionBus()
+    proxy = bus.get_object("org.kde.klipper", "/klipper")
+except:
+    raise
+
+
+class ClipboardDbusKlipper(ClipboardBase):
+
+    _is_init = False
+
+    def init(self):
+        if ClipboardDbusKlipper._is_init:
+            return
+        self.iface = dbus.Interface(proxy, "org.kde.klipper.klipper")
+        ClipboardDbusKlipper._is_init = True
+
+    def get(self, mimetype='text/plain'):
+        self.init()
+        return str(self.iface.getClipboardContents())
+
+    def put(self, data, mimetype='text/plain'):
+        self.init()
+        self.iface.setClipboardContents(data.replace('\x00', ''))
+
+    def get_types(self):
+        self.init()
+        return [u'text/plain']
diff --git a/kivy/core/clipboard/clipboard_dummy.py b/kivy/core/clipboard/clipboard_dummy.py
new file mode 100644
index 0000000..b05be30
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_dummy.py
@@ -0,0 +1,26 @@
+'''
+Clipboard Dummy: an internal implementation that does not use the system
+clipboard.
+'''
+
+__all__ = ('ClipboardDummy', )
+
+from kivy.core.clipboard import ClipboardBase
+
+
+class ClipboardDummy(ClipboardBase):
+
+    def __init__(self):
+        super(ClipboardDummy, self).__init__()
+        self._data = dict()
+        self._data['text/plain'] = None
+        self._data['application/data'] = None
+
+    def get(self, mimetype='text/plain'):
+        return self._data.get(mimetype, None)
+
+    def put(self, data, mimetype='text/plain'):
+        self._data[mimetype] = data
+
+    def get_types(self):
+        return list(self._data.keys())
diff --git a/kivy/core/clipboard/clipboard_gtk3.py b/kivy/core/clipboard/clipboard_gtk3.py
new file mode 100644
index 0000000..23f69aa
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_gtk3.py
@@ -0,0 +1,47 @@
+'''
+Clipboard Gtk3: an implementation of the Clipboard using Gtk3.
+'''
+
+__all__ = ('ClipboardGtk3',)
+
+from kivy.utils import platform
+from kivy.support import install_gobject_iteration
+from kivy.core.clipboard import ClipboardBase
+
+if platform != 'linux':
+    raise SystemError('unsupported platform for gtk3 clipboard')
+
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk, Gdk
+clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
+
+
+class ClipboardGtk3(ClipboardBase):
+
+    _is_init = False
+
+    def init(self):
+        if self._is_init:
+            return
+        install_gobject_iteration()
+        self._is_init = True
+
+    def get(self, mimetype='text/plain;charset=utf-8'):
+        self.init()
+        if mimetype == 'text/plain;charset=utf-8':
+            contents = clipboard.wait_for_text()
+            if contents:
+                return contents
+        return ''
+
+    def put(self, data, mimetype='text/plain;charset=utf-8'):
+        self.init()
+        if mimetype == 'text/plain;charset=utf-8':
+            text = data.decode(self._encoding)
+            clipboard.set_text(text, -1)
+            clipboard.store()
+
+    def get_types(self):
+        self.init()
+        return ['text/plain;charset=utf-8']
diff --git a/kivy/core/clipboard/clipboard_nspaste.py b/kivy/core/clipboard/clipboard_nspaste.py
new file mode 100644
index 0000000..66ef4c6
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_nspaste.py
@@ -0,0 +1,44 @@
+'''
+Clipboard OsX: implementation of clipboard using Appkit
+'''
+
+__all__ = ('ClipboardNSPaste', )
+
+from kivy.core.clipboard import ClipboardBase
+from kivy.utils import platform
+
+if platform != 'macosx':
+    raise SystemError('Unsupported platform for appkit clipboard.')
+try:
+    from pyobjus import autoclass
+    from pyobjus.dylib_manager import load_framework, INCLUDE
+    load_framework(INCLUDE.AppKit)
+except ImportError:
+    raise SystemError('Pyobjus not installed. Please run the following'
+        ' command to install it. `pip install --user pyobjus`')
+
+NSPasteboard = autoclass('NSPasteboard')
+NSString = autoclass('NSString')
+
+
+class ClipboardNSPaste(ClipboardBase):
+
+    def __init__(self):
+        super(ClipboardNSPaste, self).__init__()
+        self._clipboard = NSPasteboard.generalPasteboard()
+
+    def get(self, mimetype='text/plain'):
+        pb = self._clipboard
+        data = pb.stringForType_('public.utf8-plain-text')
+        if not data:
+            return ""
+        return data.UTF8String()
+
+    def put(self, data, mimetype='text/plain'):
+        pb = self._clipboard
+        pb.clearContents()
+        utf8 = NSString.alloc().initWithUTF8String_(data)
+        pb.setString_forType_(utf8, 'public.utf8-plain-text')
+
+    def get_types(self):
+        return list('text/plain',)
diff --git a/kivy/core/clipboard/clipboard_pygame.py b/kivy/core/clipboard/clipboard_pygame.py
new file mode 100644
index 0000000..8f1671d
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_pygame.py
@@ -0,0 +1,67 @@
+'''
+Clipboard Pygame: an implementation of the Clipboard using pygame.scrap.
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('ClipboardPygame', )
+
+from kivy.utils import platform
+from kivy.core.clipboard import ClipboardBase
+from kivy.utils import deprecated
+
+if platform not in ('win', 'linux', 'macosx'):
+    raise SystemError('unsupported platform for pygame clipboard')
+
+try:
+    import pygame
+    import pygame.scrap
+except:
+    raise
+
+
+class ClipboardPygame(ClipboardBase):
+
+    _is_init = False
+    _types = None
+
+    _aliases = {
+        'text/plain;charset=utf-8': 'UTF8_STRING'
+    }
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, *largs, **kwargs):
+        super(ClipboardPygame, self).__init__(*largs, **kwargs)
+
+    def init(self):
+        if ClipboardPygame._is_init:
+            return
+        pygame.scrap.init()
+        ClipboardPygame._is_init = True
+
+    def get(self, mimetype='text/plain'):
+        self.init()
+        mimetype = self._aliases.get(mimetype, mimetype)
+        text = pygame.scrap.get(mimetype)
+        return text
+
+    def put(self, data, mimetype='text/plain'):
+        self.init()
+        mimetype = self._aliases.get(mimetype, mimetype)
+        pygame.scrap.put(mimetype, data)
+
+    def get_types(self):
+        if not self._types:
+            self.init()
+            types = pygame.scrap.get_types()
+            for mime, pygtype in list(self._aliases.items())[:]:
+                if mime in types:
+                    del self._aliases[mime]
+                if pygtype in types:
+                    types.append(mime)
+            self._types = types
+        return self._types
diff --git a/kivy/core/clipboard/clipboard_sdl2.py b/kivy/core/clipboard/clipboard_sdl2.py
new file mode 100644
index 0000000..52e3f6d
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_sdl2.py
@@ -0,0 +1,36 @@
+'''
+Clipboard SDL2: an implementation of the Clipboard using sdl2.
+'''
+
+__all__ = ('ClipboardSDL2', )
+
+from kivy.utils import platform
+from kivy.core.clipboard import ClipboardBase
+
+if platform not in ('win', 'linux', 'macosx', 'android', 'ios'):
+    raise SystemError('unsupported platform for sdl2 clipboard')
+
+try:
+    from kivy.core.clipboard._clipboard_sdl2 import (
+        _get_text, _has_text, _set_text)
+except ImportError:
+    from kivy.core import handle_win_lib_import_error
+    handle_win_lib_import_error(
+        'Clipboard', 'sdl2', 'kivy.core.clipboard._clipboard_sdl2')
+    raise
+
+
+class ClipboardSDL2(ClipboardBase):
+
+    def get(self, mimetype):
+        return _get_text() if _has_text() else ''
+
+    def _ensure_clipboard(self):
+        super(ClipboardSDL2, self)._ensure_clipboard()
+        self._encoding = 'utf8'
+
+    def put(self, data=b'', mimetype='text/plain'):
+        _set_text(data)
+
+    def get_types(self):
+        return ['text/plain']
diff --git a/kivy/core/clipboard/clipboard_winctypes.py b/kivy/core/clipboard/clipboard_winctypes.py
new file mode 100644
index 0000000..59b2a92
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_winctypes.py
@@ -0,0 +1,66 @@
+'''
+Clipboard windows: an implementation of the Clipboard using ctypes.
+'''
+
+__all__ = ('ClipboardWindows', )
+
+from kivy.utils import platform
+from kivy.core.clipboard import ClipboardBase
+
+if platform != 'win':
+    raise SystemError('unsupported platform for Windows clipboard')
+
+import ctypes
+from ctypes import wintypes
+user32 = ctypes.windll.user32
+kernel32 = ctypes.windll.kernel32
+msvcrt = ctypes.cdll.msvcrt
+c_char_p = ctypes.c_char_p
+c_wchar_p = ctypes.c_wchar_p
+
+
+class ClipboardWindows(ClipboardBase):
+
+    def get(self, mimetype='text/plain'):
+        GetClipboardData = user32.GetClipboardData
+        GetClipboardData.argtypes = [wintypes.UINT]
+        GetClipboardData.restype = wintypes.HANDLE
+
+        user32.OpenClipboard(user32.GetActiveWindow())
+        # Standard Clipboard Format "1" is "CF_TEXT"
+        pcontents = GetClipboardData(13)
+
+        # if someone pastes a FILE, the content is None for SCF 13
+        # and the clipboard is locked if not closed properly
+        if not pcontents:
+            user32.CloseClipboard()
+            return ''
+        data = c_wchar_p(pcontents).value.encode(self._encoding)
+        user32.CloseClipboard()
+        return data
+
+    def put(self, text, mimetype='text/plain'):
+        text = text.decode(self._encoding)  # auto converted later
+        text += u'\x00'
+
+        SetClipboardData = user32.SetClipboardData
+        SetClipboardData.argtypes = [wintypes.UINT, wintypes.HANDLE]
+        SetClipboardData.restype = wintypes.HANDLE
+
+        GlobalAlloc = kernel32.GlobalAlloc
+        GlobalAlloc.argtypes = [wintypes.UINT, ctypes.c_size_t]
+        GlobalAlloc.restype = wintypes.HGLOBAL
+
+        CF_UNICODETEXT = 13
+
+        user32.OpenClipboard(user32.GetActiveWindow())
+        user32.EmptyClipboard()
+        hCd = GlobalAlloc(0, len(text) * ctypes.sizeof(ctypes.c_wchar))
+
+        # ignore null character for strSource pointer
+        msvcrt.wcscpy_s(c_wchar_p(hCd), len(text), c_wchar_p(text[:-1]))
+        SetClipboardData(CF_UNICODETEXT, hCd)
+        user32.CloseClipboard()
+
+    def get_types(self):
+        return ['text/plain']
diff --git a/kivy/core/clipboard/clipboard_xclip.py b/kivy/core/clipboard/clipboard_xclip.py
new file mode 100644
index 0000000..29279dd
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_xclip.py
@@ -0,0 +1,29 @@
+'''
+Clipboard xclip: an implementation of the Clipboard using xclip
+command line tool.
+'''
+
+__all__ = ('ClipboardXclip', )
+
+from kivy.utils import platform
+from kivy.core.clipboard._clipboard_ext import ClipboardExternalBase
+
+if platform != 'linux':
+    raise SystemError('unsupported platform for xclip clipboard')
+
+try:
+    import subprocess
+
+    p = subprocess.Popen(['xclip', '-version'], stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL)
+    p.communicate()
+except:
+    raise
+
+
+class ClipboardXclip(ClipboardExternalBase):
+    @staticmethod
+    def _clip(inout, selection):
+        pipe = {'std' + inout: subprocess.PIPE}
+        return subprocess.Popen(
+            ['xclip', '-' + inout, '-selection', selection], **pipe)
diff --git a/kivy/core/clipboard/clipboard_xsel.py b/kivy/core/clipboard/clipboard_xsel.py
new file mode 100644
index 0000000..9b0fee2
--- /dev/null
+++ b/kivy/core/clipboard/clipboard_xsel.py
@@ -0,0 +1,29 @@
+'''
+Clipboard xsel: an implementation of the Clipboard using xsel command line
+                tool.
+'''
+
+__all__ = ('ClipboardXsel', )
+
+from kivy.utils import platform
+from kivy.core.clipboard._clipboard_ext import ClipboardExternalBase
+
+if platform != 'linux':
+    raise SystemError('unsupported platform for xsel clipboard')
+
+try:
+    import subprocess
+    p = subprocess.Popen(['xsel'], stdout=subprocess.PIPE)
+    p.communicate()
+except:
+    raise
+
+
+class ClipboardXsel(ClipboardExternalBase):
+    @staticmethod
+    def _clip(inout, selection):
+        pipe = {'std' + inout: subprocess.PIPE}
+        sel = 'b' if selection == 'clipboard' else selection[0]
+        io = inout[0]
+        return subprocess.Popen(
+            ['xsel', '-' + sel + io], **pipe)
diff --git a/kivy/core/gl/__init__.py b/kivy/core/gl/__init__.py
new file mode 100644
index 0000000..5a647d6
--- /dev/null
+++ b/kivy/core/gl/__init__.py
@@ -0,0 +1,83 @@
+# pylint: disable=W0611
+'''
+OpenGL
+======
+
+Select and use the best OpenGL library available. Depending on your system, the
+core provider can select an OpenGL ES or a 'classic' desktop OpenGL library.
+'''
+
+import sys
+from os import environ
+
+MIN_REQUIRED_GL_VERSION = (2, 0)
+
+
+def msgbox(message):
+    if sys.platform == 'win32':
+        import ctypes
+        from ctypes.wintypes import LPCWSTR
+        ctypes.windll.user32.MessageBoxW(None, LPCWSTR(message),
+                                         u"Kivy Fatal Error", 0)
+        sys.exit(1)
+
+
+if 'KIVY_DOC' not in environ:
+
+    from kivy.logger import Logger
+    from kivy.graphics import gl_init_resources
+    from kivy.graphics.opengl_utils import gl_get_version
+    from kivy.graphics.opengl import GL_VERSION, GL_VENDOR, GL_RENDERER, \
+        GL_MAX_TEXTURE_IMAGE_UNITS, GL_MAX_TEXTURE_SIZE, \
+        GL_SHADING_LANGUAGE_VERSION,\
+        glGetString, glGetIntegerv, gl_init_symbols
+    from kivy.graphics.cgl import cgl_get_initialized_backend_name
+    from kivy.utils import platform
+
+    def init_gl(allowed=[], ignored=[]):
+        gl_init_symbols(allowed, ignored)
+        print_gl_version()
+        gl_init_resources()
+
+    def print_gl_version():
+        backend = cgl_get_initialized_backend_name()
+        Logger.info('GL: Backend used <{}>'.format(backend))
+        version = glGetString(GL_VERSION)
+        vendor = glGetString(GL_VENDOR)
+        renderer = glGetString(GL_RENDERER)
+        Logger.info('GL: OpenGL version <{0}>'.format(version))
+        Logger.info('GL: OpenGL vendor <{0}>'.format(vendor))
+        Logger.info('GL: OpenGL renderer <{0}>'.format(renderer))
+
+        # Let the user know if his graphics hardware/drivers are too old
+        major, minor = gl_get_version()
+        Logger.info('GL: OpenGL parsed version: %d, %d' % (major, minor))
+        if ((major, minor) < MIN_REQUIRED_GL_VERSION and backend != "mock"):
+            if hasattr(sys, "_kivy_opengl_required_func"):
+                sys._kivy_opengl_required_func(major, minor, version, vendor,
+                                               renderer)
+            else:
+                msg = (
+                    'GL: Minimum required OpenGL version (2.0) NOT found!\n\n'
+                    'OpenGL version detected: {0}.{1}\n\n'
+                    'Version: {2}\nVendor: {3}\nRenderer: {4}\n\n'
+                    'Try upgrading your graphics drivers and/or your '
+                    'graphics hardware in case of problems.\n\n'
+                    'The application will leave now.').format(
+                        major, minor, version, vendor, renderer)
+                Logger.critical(msg)
+                msgbox(msg)
+
+        if platform != 'android':
+            # XXX in the android emulator (latest version at 22 march 2013),
+            # this call was segfaulting the gl stack.
+            Logger.info('GL: Shading version <{0}>'.format(glGetString(
+                GL_SHADING_LANGUAGE_VERSION)))
+        Logger.info('GL: Texture max size <{0}>'.format(glGetIntegerv(
+            GL_MAX_TEXTURE_SIZE)[0]))
+        Logger.info('GL: Texture max units <{0}>'.format(glGetIntegerv(
+            GL_MAX_TEXTURE_IMAGE_UNITS)[0]))
+
+    # To be able to use our GL provider, we must have a window
+    # Automatically import window auto to ensure the default window creation
+    import kivy.core.window  # NOQA
diff --git a/kivy/core/gl/__pycache__/__init__.cpython-310.pyc b/kivy/core/gl/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..68186ff
Binary files /dev/null and b/kivy/core/gl/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/image/__init__.py b/kivy/core/image/__init__.py
new file mode 100644
index 0000000..d01cde6
--- /dev/null
+++ b/kivy/core/image/__init__.py
@@ -0,0 +1,1002 @@
+'''
+Image
+=====
+
+Core classes for loading images and converting them to a
+:class:`~kivy.graphics.texture.Texture`. The raw image data can be keep in
+memory for further access.
+
+.. versionchanged:: 1.11.0
+
+    Add support for argb and abgr image data
+
+In-memory image loading
+-----------------------
+
+.. versionadded:: 1.9.0
+
+    Official support for in-memory loading. Not all the providers support it,
+    but currently SDL2, pygame, pil and imageio work.
+
+To load an image with a filename, you would usually do::
+
+    from kivy.core.image import Image as CoreImage
+    im = CoreImage("image.png")
+
+You can also load the image data directly from a memory block. Instead of
+passing the filename, you'll need to pass the data as a BytesIO object
+together with an "ext" parameter. Both are mandatory::
+
+    import io
+    from kivy.core.image import Image as CoreImage
+    data = io.BytesIO(open("image.png", "rb").read())
+    im = CoreImage(data, ext="png")
+
+By default, the image will not be cached as our internal cache requires a
+filename. If you want caching, add a filename that represents your file (it
+will be used only for caching)::
+
+    import io
+    from kivy.core.image import Image as CoreImage
+    data = io.BytesIO(open("image.png", "rb").read())
+    im = CoreImage(data, ext="png", filename="image.png")
+
+Saving an image
+---------------
+
+A CoreImage can be saved to a file::
+
+    from kivy.core.image import Image as CoreImage
+    image = CoreImage(...)
+    image.save("/tmp/test.png")
+
+Or you can get the bytes (new in `1.11.0`):
+
+    import io
+    from kivy.core.image import Image as CoreImage
+    data = io.BytesIO()
+    image = CoreImage(...)
+    image.save(data, fmt="png")
+    png_bytes = data.read()
+
+'''
+import re
+from base64 import b64decode
+import imghdr
+
+__all__ = ('Image', 'ImageLoader', 'ImageData')
+
+from kivy.event import EventDispatcher
+from kivy.core import core_register_libs
+from kivy.logger import Logger
+from kivy.cache import Cache
+from kivy.clock import Clock
+from kivy.atlas import Atlas
+from kivy.resources import resource_find
+from kivy.utils import platform
+from kivy.compat import string_types
+from kivy.setupconfig import USE_SDL2
+import zipfile
+from io import BytesIO
+
+
+# late binding
+Texture = TextureRegion = None
+
+
+# register image caching only for keep_data=True
+Cache.register('kv.image', timeout=60)
+Cache.register('kv.atlas')
+
+
+class ImageData(object):
+    '''Container for images and mipmap images.
+    The container will always have at least the mipmap level 0.
+    '''
+
+    __slots__ = ('fmt', 'mipmaps', 'source', 'flip_vertical', 'source_image')
+    _supported_fmts = ('rgb', 'bgr', 'rgba', 'bgra', 'argb', 'abgr',
+                       's3tc_dxt1', 's3tc_dxt3', 's3tc_dxt5', 'pvrtc_rgb2',
+                       'pvrtc_rgb4', 'pvrtc_rgba2', 'pvrtc_rgba4', 'etc1_rgb8')
+
+    def __init__(self, width, height, fmt, data, source=None,
+                 flip_vertical=True, source_image=None,
+                 rowlength=0):
+        assert fmt in ImageData._supported_fmts
+
+        #: Decoded image format, one of a available texture format
+        self.fmt = fmt
+
+        #: Data for each mipmap.
+        self.mipmaps = {}
+        self.add_mipmap(0, width, height, data, rowlength)
+
+        #: Image source, if available
+        self.source = source
+
+        #: Indicate if the texture will need to be vertically flipped
+        self.flip_vertical = flip_vertical
+
+        # the original image, which we might need to save if it is a memoryview
+        self.source_image = source_image
+
+    def release_data(self):
+        mm = self.mipmaps
+        for item in mm.values():
+            item[2] = None
+            self.source_image = None
+
+    @property
+    def width(self):
+        '''Image width in pixels.
+        (If the image is mipmapped, it will use the level 0)
+        '''
+        return self.mipmaps[0][0]
+
+    @property
+    def height(self):
+        '''Image height in pixels.
+        (If the image is mipmapped, it will use the level 0)
+        '''
+        return self.mipmaps[0][1]
+
+    @property
+    def data(self):
+        '''Image data.
+        (If the image is mipmapped, it will use the level 0)
+        '''
+        return self.mipmaps[0][2]
+
+    @property
+    def rowlength(self):
+        '''Image rowlength.
+        (If the image is mipmapped, it will use the level 0)
+
+        .. versionadded:: 1.9.0
+        '''
+        return self.mipmaps[0][3]
+
+    @property
+    def size(self):
+        '''Image (width, height) in pixels.
+        (If the image is mipmapped, it will use the level 0)
+        '''
+        mm = self.mipmaps[0]
+        return mm[0], mm[1]
+
+    @property
+    def have_mipmap(self):
+        return len(self.mipmaps) > 1
+
+    def __repr__(self):
+        return ('<ImageData width=%d height=%d fmt=%s '
+                'source=%r with %d images>' % (
+                    self.width, self.height, self.fmt,
+                    self.source, len(self.mipmaps)))
+
+    def add_mipmap(self, level, width, height, data, rowlength):
+        '''Add a image for a specific mipmap level.
+
+        .. versionadded:: 1.0.7
+        '''
+        self.mipmaps[level] = [int(width), int(height), data, rowlength]
+
+    def get_mipmap(self, level):
+        '''Get the mipmap image at a specific level if it exists
+
+        .. versionadded:: 1.0.7
+        '''
+        if level == 0:
+            return (self.width, self.height, self.data, self.rowlength)
+        assert(level < len(self.mipmaps))
+        return self.mipmaps[level]
+
+    def iterate_mipmaps(self):
+        '''Iterate over all mipmap images available.
+
+        .. versionadded:: 1.0.7
+        '''
+        mm = self.mipmaps
+        for x in range(len(mm)):
+            item = mm.get(x, None)
+            if item is None:
+                raise Exception('Invalid mipmap level, found empty one')
+            yield x, item[0], item[1], item[2], item[3]
+
+
+class ImageLoaderBase(object):
+    '''Base to implement an image loader.'''
+
+    __slots__ = ('_texture', '_data', 'filename', 'keep_data',
+                 '_mipmap', '_nocache', '_ext', '_inline')
+
+    def __init__(self, filename, **kwargs):
+        self._mipmap = kwargs.get('mipmap', False)
+        self.keep_data = kwargs.get('keep_data', False)
+        self._nocache = kwargs.get('nocache', False)
+        self._ext = kwargs.get('ext')
+        self._inline = kwargs.get('inline')
+        self.filename = filename
+        if self._inline:
+            self._data = self.load(kwargs.get('rawdata'))
+        else:
+            self._data = self.load(filename)
+        self._textures = None
+
+    def load(self, filename):
+        '''Load an image'''
+        return None
+
+    @staticmethod
+    def can_save(fmt, is_bytesio=False):
+        '''Indicate if the loader can save the Image object
+
+        .. versionchanged:: 1.11.0
+            Parameter `fmt` and `is_bytesio` added
+        '''
+        return False
+
+    @staticmethod
+    def can_load_memory():
+        '''Indicate if the loader can load an image by passing data
+        '''
+        return False
+
+    @staticmethod
+    def save(*largs, **kwargs):
+        raise NotImplementedError()
+
+    def populate(self):
+        self._textures = []
+        fname = self.filename
+        if __debug__:
+            Logger.trace('Image: %r, populate to textures (%d)' %
+                         (fname, len(self._data)))
+
+        for count in range(len(self._data)):
+
+            # first, check if a texture with the same name already exist in the
+            # cache
+            chr = type(fname)
+            uid = chr(u'%s|%d|%d') % (fname, self._mipmap, count)
+            texture = Cache.get('kv.texture', uid)
+
+            # if not create it and append to the cache
+            if texture is None:
+                imagedata = self._data[count]
+                source = '{}{}|'.format(
+                    'zip|' if fname.endswith('.zip') else '',
+                    self._nocache)
+                imagedata.source = chr(source) + uid
+                texture = Texture.create_from_data(
+                    imagedata, mipmap=self._mipmap)
+                if not self._nocache:
+                    Cache.append('kv.texture', uid, texture)
+                if imagedata.flip_vertical:
+                    texture.flip_vertical()
+
+            # set as our current texture
+            self._textures.append(texture)
+
+            # release data if ask
+            if not self.keep_data:
+                self._data[count].release_data()
+
+    @property
+    def width(self):
+        '''Image width
+        '''
+        return self._data[0].width
+
+    @property
+    def height(self):
+        '''Image height
+        '''
+        return self._data[0].height
+
+    @property
+    def size(self):
+        '''Image size (width, height)
+        '''
+        return (self._data[0].width, self._data[0].height)
+
+    @property
+    def texture(self):
+        '''Get the image texture (created on the first call)
+        '''
+        if self._textures is None:
+            self.populate()
+        if self._textures is None:
+            return None
+        return self._textures[0]
+
+    @property
+    def textures(self):
+        '''Get the textures list (for mipmapped image or animated image)
+
+        .. versionadded:: 1.0.8
+        '''
+        if self._textures is None:
+            self.populate()
+        return self._textures
+
+    @property
+    def nocache(self):
+        '''Indicate if the texture will not be stored in the cache
+
+        .. versionadded:: 1.6.0
+        '''
+        return self._nocache
+
+
+class ImageLoader(object):
+
+    loaders = []
+
+    @staticmethod
+    def zip_loader(filename, **kwargs):
+        '''Read images from an zip file.
+
+        .. versionadded:: 1.0.8
+
+        Returns an Image with a list of type ImageData stored in Image._data
+        '''
+        # read zip in memory for faster access
+        _file = BytesIO(open(filename, 'rb').read())
+        # read all images inside the zip
+        z = zipfile.ZipFile(_file)
+        image_data = []
+        # sort filename list
+        znamelist = z.namelist()
+        znamelist.sort()
+        image = None
+        for zfilename in znamelist:
+            try:
+                # read file and store it in mem with fileIO struct around it
+                tmpfile = BytesIO(z.read(zfilename))
+                ext = zfilename.split('.')[-1].lower()
+                im = None
+                for loader in ImageLoader.loaders:
+                    if (ext not in loader.extensions() or
+                            not loader.can_load_memory()):
+                        continue
+                    Logger.debug('Image%s: Load <%s> from <%s>' %
+                                 (loader.__name__[11:], zfilename, filename))
+                    try:
+                        im = loader(zfilename, ext=ext, rawdata=tmpfile,
+                                    inline=True, **kwargs)
+                    except:
+                        # Loader failed, continue trying.
+                        continue
+                    break
+                if im is not None:
+                    # append ImageData to local variable before its
+                    # overwritten
+                    image_data.append(im._data[0])
+                    image = im
+                # else: if not image file skip to next
+            except:
+                Logger.warning('Image: Unable to load image'
+                               '<%s> in zip <%s> trying to continue...'
+                               % (zfilename, filename))
+        z.close()
+        if len(image_data) == 0:
+            raise Exception('no images in zip <%s>' % filename)
+        # replace Image.Data with the array of all the images in the zip
+        image._data = image_data
+        image.filename = filename
+        return image
+
+    @staticmethod
+    def register(defcls):
+        ImageLoader.loaders.append(defcls)
+
+    @staticmethod
+    def load(filename, **kwargs):
+
+        # atlas ?
+        if filename[:8] == 'atlas://':
+            # remove the url
+            rfn = filename[8:]
+            # last field is the ID
+            try:
+                rfn, uid = rfn.rsplit('/', 1)
+            except ValueError:
+                raise ValueError(
+                    'Image: Invalid %s name for atlas' % filename)
+
+            # search if we already got the atlas loaded
+            atlas = Cache.get('kv.atlas', rfn)
+
+            # atlas already loaded, so reupload the missing texture in cache,
+            # because when it's not in use, the texture can be removed from the
+            # kv.texture cache.
+            if atlas:
+                texture = atlas[uid]
+                fn = 'atlas://%s/%s' % (rfn, uid)
+                cid = '{}|{:d}|{:d}'.format(fn, False, 0)
+                Cache.append('kv.texture', cid, texture)
+                return Image(texture)
+
+            # search with resource
+            afn = rfn
+            if not afn.endswith('.atlas'):
+                afn += '.atlas'
+            afn = resource_find(afn)
+            if not afn:
+                raise Exception('Unable to find %r atlas' % afn)
+            atlas = Atlas(afn)
+            Cache.append('kv.atlas', rfn, atlas)
+            # first time, fill our texture cache.
+            for nid, texture in atlas.textures.items():
+                fn = 'atlas://%s/%s' % (rfn, nid)
+                cid = '{}|{:d}|{:d}'.format(fn, False, 0)
+                Cache.append('kv.texture', cid, texture)
+            return Image(atlas[uid])
+
+        # extract extensions
+        ext = filename.split('.')[-1].lower()
+
+        # prevent url querystrings
+        if filename.startswith((('http://', 'https://'))):
+            ext = ext.split('?')[0]
+
+        filename = resource_find(filename)
+
+        # special case. When we are trying to load a "zip" file with image, we
+        # will use the special zip_loader in ImageLoader. This might return a
+        # sequence of images contained in the zip.
+        if ext == 'zip':
+            return ImageLoader.zip_loader(filename)
+        else:
+            im = None
+            # Get actual image format instead of extension if possible
+            ext = imghdr.what(filename) or ext
+            for loader in ImageLoader.loaders:
+                if ext not in loader.extensions():
+                    continue
+                Logger.debug('Image%s: Load <%s>' %
+                             (loader.__name__[11:], filename))
+                im = loader(filename, **kwargs)
+                break
+            if im is None:
+                raise Exception('Unknown <%s> type, no loader found.' % ext)
+            return im
+
+
+class Image(EventDispatcher):
+    '''Load an image and store the size and texture.
+
+    .. versionchanged:: 1.0.7
+
+        `mipmap` attribute has been added. The `texture_mipmap` and
+        `texture_rectangle` have been deleted.
+
+    .. versionchanged:: 1.0.8
+
+        An Image widget can change its texture. A new event 'on_texture' has
+        been introduced. New methods for handling sequenced animation have been
+        added.
+
+    :Parameters:
+        `arg`: can be a string (str), Texture, BytesIO or Image object
+            A string path to the image file or data URI to be loaded; or a
+            Texture object, which will be wrapped in an Image object; or a
+            BytesIO object containing raw image data; or an already existing
+            image object, in which case, a real copy of the given image object
+            will be returned.
+        `keep_data`: bool, defaults to False
+            Keep the image data when the texture is created.
+        `mipmap`: bool, defaults to False
+            Create mipmap for the texture.
+        `anim_delay`: float, defaults to .25
+            Delay in seconds between each animation frame. Lower values means
+            faster animation.
+        `ext`: str, only with BytesIO `arg`
+            File extension to use in determining how to load raw image data.
+        `filename`: str, only with BytesIO `arg`
+            Filename to use in the image cache for raw image data.
+    '''
+
+    copy_attributes = ('_size', '_filename', '_texture', '_image',
+                       '_mipmap', '_nocache')
+
+    data_uri_re = re.compile(r'^data:image/([^;,]*)(;[^,]*)?,(.*)$')
+
+    _anim_ev = None
+
+    def __init__(self, arg, **kwargs):
+        # this event should be fired on animation of sequenced img's
+        self.register_event_type('on_texture')
+
+        super(Image, self).__init__()
+
+        self._mipmap = kwargs.get('mipmap', False)
+        self._keep_data = kwargs.get('keep_data', False)
+        self._nocache = kwargs.get('nocache', False)
+        self._size = [0, 0]
+        self._image = None
+        self._filename = None
+        self._texture = None
+        self._anim_available = False
+        self._anim_index = 0
+        self._anim_delay = 0
+        self.anim_delay = kwargs.get('anim_delay', .25)
+        # indicator of images having been loded in cache
+        self._iteration_done = False
+
+        if isinstance(arg, Image):
+            for attr in Image.copy_attributes:
+                self.__setattr__(attr, arg.__getattribute__(attr))
+        elif type(arg) in (Texture, TextureRegion):
+            if not hasattr(self, 'textures'):
+                self.textures = []
+                self.textures.append(arg)
+            self._texture = arg
+            self._size = self.texture.size
+        elif isinstance(arg, ImageLoaderBase):
+            self.image = arg
+        elif isinstance(arg, BytesIO):
+            ext = kwargs.get('ext', None)
+            if not ext:
+                raise Exception('Inline loading require "ext" parameter')
+            filename = kwargs.get('filename')
+            if not filename:
+                self._nocache = True
+                filename = '__inline__'
+            self.load_memory(arg, ext, filename)
+        elif isinstance(arg, string_types):
+            groups = self.data_uri_re.findall(arg)
+            if groups:
+                self._nocache = True
+                imtype, optstr, data = groups[0]
+                options = [o for o in optstr.split(';') if o]
+                ext = imtype
+                isb64 = 'base64' in options
+                if data:
+                    if isb64:
+                        data = b64decode(data)
+                    self.load_memory(BytesIO(data), ext)
+            else:
+                self.filename = arg
+        else:
+            raise Exception('Unable to load image type {0!r}'.format(arg))
+
+    def remove_from_cache(self):
+        '''Remove the Image from cache. This facilitates re-loading of
+        images from disk in case the image content has changed.
+
+        .. versionadded:: 1.3.0
+
+        Usage::
+
+            im = CoreImage('1.jpg')
+            # -- do something --
+            im.remove_from_cache()
+            im = CoreImage('1.jpg')
+            # this time image will be re-loaded from disk
+
+        '''
+        count = 0
+        f = self.filename
+        pat = type(f)(u'%s|%d|%d')
+        uid = pat % (f, self._mipmap, count)
+        Cache.remove("kv.image", uid)
+        while Cache.get("kv.texture", uid):
+            Cache.remove("kv.texture", uid)
+            count += 1
+            uid = pat % (f, self._mipmap, count)
+
+    def _anim(self, *largs):
+        if not self._image:
+            return
+        textures = self.image.textures
+        if self._anim_index >= len(textures):
+            self._anim_index = 0
+        self._texture = self.image.textures[self._anim_index]
+        self.dispatch('on_texture')
+        self._anim_index += 1
+        self._anim_index %= len(self._image.textures)
+
+    def anim_reset(self, allow_anim):
+        '''Reset an animation if available.
+
+        .. versionadded:: 1.0.8
+
+        :Parameters:
+            `allow_anim`: bool
+                Indicate whether the animation should restart playing or not.
+
+        Usage::
+
+            # start/reset animation
+            image.anim_reset(True)
+
+            # or stop the animation
+            image.anim_reset(False)
+
+        You can change the animation speed whilst it is playing::
+
+            # Set to 20 FPS
+            image.anim_delay = 1 / 20.
+
+        '''
+        # stop animation
+        if self._anim_ev is not None:
+            self._anim_ev.cancel()
+            self._anim_ev = None
+
+        if allow_anim and self._anim_available and self._anim_delay >= 0:
+            self._anim_ev = Clock.schedule_interval(self._anim,
+                                                    self.anim_delay)
+            self._anim()
+
+    def _get_anim_delay(self):
+        return self._anim_delay
+
+    def _set_anim_delay(self, x):
+        if self._anim_delay == x:
+            return
+        self._anim_delay = x
+        if self._anim_available:
+            if self._anim_ev is not None:
+                self._anim_ev.cancel()
+                self._anim_ev = None
+
+            if self._anim_delay >= 0:
+                self._anim_ev = Clock.schedule_interval(self._anim,
+                                                        self._anim_delay)
+
+    anim_delay = property(_get_anim_delay, _set_anim_delay)
+    '''Delay between each animation frame. A lower value means faster
+    animation.
+
+    .. versionadded:: 1.0.8
+    '''
+
+    @property
+    def anim_available(self):
+        '''Return True if this Image instance has animation available.
+
+        .. versionadded:: 1.0.8
+        '''
+        return self._anim_available
+
+    @property
+    def anim_index(self):
+        '''Return the index number of the image currently in the texture.
+
+        .. versionadded:: 1.0.8
+        '''
+        return self._anim_index
+
+    def _img_iterate(self, *largs):
+        if not self.image or self._iteration_done:
+            return
+        self._iteration_done = True
+        imgcount = len(self.image.textures)
+        if imgcount > 1:
+            self._anim_available = True
+            self.anim_reset(True)
+        self._texture = self.image.textures[0]
+
+    def on_texture(self, *largs):
+        '''This event is fired when the texture reference or content has
+           changed. It is normally used for sequenced images.
+
+        .. versionadded:: 1.0.8
+        '''
+        pass
+
+    @staticmethod
+    def load(filename, **kwargs):
+        '''Load an image
+
+        :Parameters:
+            `filename`: str
+                Filename of the image.
+            `keep_data`: bool, defaults to False
+                Keep the image data when the texture is created.
+        '''
+        kwargs.setdefault('keep_data', False)
+        return Image(filename, **kwargs)
+
+    def _get_image(self):
+        return self._image
+
+    def _set_image(self, image):
+        self._image = image
+        if hasattr(image, 'filename'):
+            self._filename = image.filename
+        if image:
+            self._size = (self.image.width, self.image.height)
+
+    image = property(_get_image, _set_image,
+                     doc='Get/set the data image object')
+
+    def _get_filename(self):
+        return self._filename
+
+    def _set_filename(self, value):
+        if value is None or value == self._filename:
+            return
+        self._filename = value
+
+        # construct uid as a key for Cache
+        f = self.filename
+        uid = type(f)(u'%s|%d|%d') % (f, self._mipmap, 0)
+
+        # in case of Image have been asked with keep_data
+        # check the kv.image cache instead of texture.
+        image = Cache.get('kv.image', uid)
+        if image:
+            # we found an image, yeah ! but reset the texture now.
+            self.image = image
+            # if image.__class__ is core image then it's a texture
+            # from atlas or other sources and has no data so skip
+            if (image.__class__ != self.__class__ and
+                    not image.keep_data and self._keep_data):
+                self.remove_from_cache()
+                self._filename = ''
+                self._set_filename(value)
+            else:
+                self._texture = None
+            return
+        else:
+            # if we already got a texture, it will be automatically reloaded.
+            _texture = Cache.get('kv.texture', uid)
+            if _texture:
+                self._texture = _texture
+                return
+
+        # if image not already in cache then load
+        tmpfilename = self._filename
+        image = ImageLoader.load(
+            self._filename, keep_data=self._keep_data,
+            mipmap=self._mipmap, nocache=self._nocache)
+        self._filename = tmpfilename
+        # put the image into the cache if needed
+        if isinstance(image, Texture):
+            self._texture = image
+            self._size = image.size
+        else:
+            self.image = image
+            if not self._nocache:
+                Cache.append('kv.image', uid, self.image)
+
+    filename = property(_get_filename, _set_filename,
+                        doc='Get/set the filename of image')
+
+    def load_memory(self, data, ext, filename='__inline__'):
+        '''(internal) Method to load an image from raw data.
+        '''
+        self._filename = filename
+
+        # see if there is a available loader for it
+        loaders = [loader for loader in ImageLoader.loaders if
+                   loader.can_load_memory() and
+                   ext in loader.extensions()]
+        if not loaders:
+            raise Exception('No inline loader found to load {}'.format(ext))
+        image = loaders[0](filename, ext=ext, rawdata=data, inline=True,
+                nocache=self._nocache, mipmap=self._mipmap,
+                keep_data=self._keep_data)
+        if isinstance(image, Texture):
+            self._texture = image
+            self._size = image.size
+        else:
+            self.image = image
+
+    @property
+    def size(self):
+        '''Image size (width, height)
+        '''
+        return self._size
+
+    @property
+    def width(self):
+        '''Image width
+        '''
+        return self._size[0]
+
+    @property
+    def height(self):
+        '''Image height
+        '''
+        return self._size[1]
+
+    @property
+    def texture(self):
+        '''Texture of the image'''
+        if self.image:
+            if not self._iteration_done:
+                self._img_iterate()
+        return self._texture
+
+    @property
+    def nocache(self):
+        '''Indicate whether the texture will not be stored in the cache or not.
+
+        .. versionadded:: 1.6.0
+        '''
+        return self._nocache
+
+    def save(self, filename, flipped=False, fmt=None):
+        '''Save image texture to file.
+
+        The filename should have the '.png' extension because the texture data
+        read from the GPU is in the RGBA format. '.jpg' might work but has not
+        been heavily tested so some providers might break when using it.
+        Any other extensions are not officially supported.
+
+        The flipped parameter flips the saved image vertically, and
+        defaults to False.
+
+        Example::
+
+            # Save an core image object
+            from kivy.core.image import Image
+            img = Image('hello.png')
+            img.save('hello2.png')
+
+            # Save a texture
+            texture = Texture.create(...)
+            img = Image(texture)
+            img.save('hello3.png')
+
+        .. versionadded:: 1.7.0
+
+        .. versionchanged:: 1.8.0
+            Parameter `flipped` added to flip the image before saving, default
+            to False.
+
+        .. versionchanged:: 1.11.0
+            Parameter `fmt` added to force the output format of the file
+            Filename can now be a BytesIO object.
+
+        '''
+        is_bytesio = False
+        if isinstance(filename, BytesIO):
+            is_bytesio = True
+            if not fmt:
+                raise Exception(
+                    "You must specify a format to save into a BytesIO object")
+        elif fmt is None:
+            fmt = self._find_format_from_filename(filename)
+
+        pixels = None
+        size = None
+        loaders = [
+            x for x in ImageLoader.loaders
+            if x.can_save(fmt, is_bytesio=is_bytesio)
+        ]
+        if not loaders:
+            return False
+        loader = loaders[0]
+
+        if self.image:
+            # we might have a ImageData object to use
+            data = self.image._data[0]
+            if data.data is not None:
+                if data.fmt in ('rgba', 'rgb'):
+                    # fast path, use the "raw" data when keep_data is used
+                    size = data.width, data.height
+                    pixels = data.data
+
+                else:
+                    # the format is not rgba, we need to convert it.
+                    # use texture for that.
+                    self.populate()
+
+        if pixels is None and self._texture:
+            # use the texture pixels
+            size = self._texture.size
+            pixels = self._texture.pixels
+
+        if pixels is None:
+            return False
+
+        l_pixels = len(pixels)
+        if l_pixels == size[0] * size[1] * 3:
+            pixelfmt = 'rgb'
+        elif l_pixels == size[0] * size[1] * 4:
+            pixelfmt = 'rgba'
+        else:
+            raise Exception('Unable to determine the format of the pixels')
+        return loader.save(
+            filename, size[0], size[1], pixelfmt, pixels, flipped, fmt)
+
+    def _find_format_from_filename(self, filename):
+        ext = filename.rsplit(".", 1)[-1].lower()
+        if ext in {
+                'bmp', 'jpe', 'lbm', 'pcx', 'png', 'pnm',
+                'tga', 'tiff', 'webp', 'xcf', 'xpm', 'xv'}:
+            return ext
+        elif ext in ('jpg', 'jpeg'):
+            return 'jpg'
+        elif ext in ('b64', 'base64'):
+            return 'base64'
+        return None
+
+    def read_pixel(self, x, y):
+        '''For a given local x/y position, return the pixel color at that
+        position.
+
+        .. warning::
+            This function can only be used with images loaded with the
+            keep_data=True keyword. For example::
+
+                m = Image.load('image.png', keep_data=True)
+                color = m.read_pixel(150, 150)
+
+        :Parameters:
+            `x`: int
+                Local x coordinate of the pixel in question.
+            `y`: int
+                Local y coordinate of the pixel in question.
+        '''
+        data = self.image._data[0]
+
+        # can't use this function without ImageData
+        if data.data is None:
+            raise EOFError('Image data is missing, make sure that image is'
+                           'loaded with keep_data=True keyword.')
+
+        # check bounds
+        x, y = int(x), int(y)
+        if not (0 <= x < data.width and 0 <= y < data.height):
+            raise IndexError('Position (%d, %d) is out of range.' % (x, y))
+
+        assert data.fmt in ImageData._supported_fmts
+        size = 3 if data.fmt in ('rgb', 'bgr') else 4
+        index = y * data.width * size + x * size
+        raw = bytearray(data.data[index:index + size])
+        color = [c / 255.0 for c in raw]
+
+        bgr_flag = False
+        if data.fmt == 'argb':
+            color.reverse()  # bgra
+            bgr_flag = True
+        elif data.fmt == 'abgr':
+            color.reverse()  # rgba
+
+        # conversion for BGR->RGB, BGRA->RGBA format
+        if bgr_flag or data.fmt in ('bgr', 'bgra'):
+            color[0], color[2] = color[2], color[0]
+
+        return color
+
+
+def load(filename):
+    '''Load an image'''
+    return Image.load(filename)
+
+
+# load image loaders
+image_libs = []
+
+if platform in ('macosx', 'ios'):
+    image_libs += [('imageio', 'img_imageio')]
+
+image_libs += [
+    ('tex', 'img_tex'),
+    ('dds', 'img_dds')]
+if USE_SDL2:
+    image_libs += [('sdl2', 'img_sdl2')]
+else:
+    image_libs += [('pygame', 'img_pygame')]
+image_libs += [
+    ('ffpy', 'img_ffpyplayer'),
+    ('pil', 'img_pil')]
+
+libs_loaded = core_register_libs('image', image_libs)
+
+from os import environ
+if 'KIVY_DOC' not in environ and not libs_loaded:
+    import sys
+
+    Logger.critical('App: Unable to get any Image provider, abort.')
+    sys.exit(1)
+
+# resolve binding.
+from kivy.graphics.texture import Texture, TextureRegion
diff --git a/kivy/core/image/__pycache__/__init__.cpython-310.pyc b/kivy/core/image/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..001c2be
Binary files /dev/null and b/kivy/core/image/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/image/__pycache__/img_dds.cpython-310.pyc b/kivy/core/image/__pycache__/img_dds.cpython-310.pyc
new file mode 100644
index 0000000..3d608c7
Binary files /dev/null and b/kivy/core/image/__pycache__/img_dds.cpython-310.pyc differ
diff --git a/kivy/core/image/__pycache__/img_ffpyplayer.cpython-310.pyc b/kivy/core/image/__pycache__/img_ffpyplayer.cpython-310.pyc
new file mode 100644
index 0000000..8805b85
Binary files /dev/null and b/kivy/core/image/__pycache__/img_ffpyplayer.cpython-310.pyc differ
diff --git a/kivy/core/image/__pycache__/img_pil.cpython-310.pyc b/kivy/core/image/__pycache__/img_pil.cpython-310.pyc
new file mode 100644
index 0000000..44f4882
Binary files /dev/null and b/kivy/core/image/__pycache__/img_pil.cpython-310.pyc differ
diff --git a/kivy/core/image/__pycache__/img_pygame.cpython-310.pyc b/kivy/core/image/__pycache__/img_pygame.cpython-310.pyc
new file mode 100644
index 0000000..7b5d5ab
Binary files /dev/null and b/kivy/core/image/__pycache__/img_pygame.cpython-310.pyc differ
diff --git a/kivy/core/image/__pycache__/img_sdl2.cpython-310.pyc b/kivy/core/image/__pycache__/img_sdl2.cpython-310.pyc
new file mode 100644
index 0000000..53b0c03
Binary files /dev/null and b/kivy/core/image/__pycache__/img_sdl2.cpython-310.pyc differ
diff --git a/kivy/core/image/__pycache__/img_tex.cpython-310.pyc b/kivy/core/image/__pycache__/img_tex.cpython-310.pyc
new file mode 100644
index 0000000..ca4a965
Binary files /dev/null and b/kivy/core/image/__pycache__/img_tex.cpython-310.pyc differ
diff --git a/kivy/core/image/_img_sdl2.cpython-310-x86_64-linux-gnu.so b/kivy/core/image/_img_sdl2.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..4c28cc1
Binary files /dev/null and b/kivy/core/image/_img_sdl2.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/core/image/img_dds.py b/kivy/core/image/img_dds.py
new file mode 100644
index 0000000..adb6f27
--- /dev/null
+++ b/kivy/core/image/img_dds.py
@@ -0,0 +1,40 @@
+'''
+DDS: DDS image loader
+'''
+
+__all__ = ('ImageLoaderDDS', )
+
+from kivy.lib.ddsfile import DDSFile
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+
+class ImageLoaderDDS(ImageLoaderBase):
+
+    @staticmethod
+    def extensions():
+        return ('dds', )
+
+    def load(self, filename):
+        try:
+            dds = DDSFile(filename=filename)
+        except:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise
+
+        self.filename = filename
+        width, height = dds.size
+        im = ImageData(width, height, dds.dxt, dds.images[0], source=filename,
+                       flip_vertical=False)
+        if len(dds.images) > 1:
+            images = dds.images
+            images_size = dds.images_size
+            for index in range(1, len(dds.images)):
+                w, h = images_size[index]
+                data = images[index]
+                im.add_mipmap(index, w, h, data)
+        return [im]
+
+
+# register
+ImageLoader.register(ImageLoaderDDS)
diff --git a/kivy/core/image/img_ffpyplayer.py b/kivy/core/image/img_ffpyplayer.py
new file mode 100644
index 0000000..1533839
--- /dev/null
+++ b/kivy/core/image/img_ffpyplayer.py
@@ -0,0 +1,87 @@
+'''
+FFPyPlayer: FFmpeg based image loader
+'''
+
+__all__ = ('ImageLoaderFFPy', )
+
+import ffpyplayer
+from ffpyplayer.pic import ImageLoader as ffImageLoader, SWScale
+from ffpyplayer.tools import set_log_callback, get_log_callback
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+
+Logger.info('ImageLoaderFFPy: Using ffpyplayer {}'.format(ffpyplayer.version))
+
+
+logger_func = {'quiet': Logger.critical, 'panic': Logger.critical,
+               'fatal': Logger.critical, 'error': Logger.error,
+               'warning': Logger.warning, 'info': Logger.info,
+               'verbose': Logger.debug, 'debug': Logger.debug}
+
+
+def _log_callback(message, level):
+    message = message.strip()
+    if message:
+        logger_func[level]('ffpyplayer: {}'.format(message))
+
+
+if not get_log_callback():
+    set_log_callback(_log_callback)
+
+
+class ImageLoaderFFPy(ImageLoaderBase):
+    '''Image loader based on the ffpyplayer library.
+
+    .. versionadded:: 1.9.0
+
+    .. note:
+        This provider may support more formats than what is listed in
+        :meth:`extensions`.
+    '''
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        # See https://www.ffmpeg.org/general.html#Image-Formats
+        return ('bmp', 'dpx', 'exr', 'gif', 'ico', 'jpeg', 'jpg2000', 'jpg',
+                'jls', 'pam', 'pbm', 'pcx', 'pgm', 'pgmyuv', 'pic', 'png',
+                'ppm', 'ptx', 'sgi', 'ras', 'tga', 'tiff', 'webp', 'xbm',
+                'xface', 'xwd')
+
+    def load(self, filename):
+        try:
+            loader = ffImageLoader(filename)
+        except:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise
+
+        # update internals
+        self.filename = filename
+        images = []
+
+        while True:
+            frame, t = loader.next_frame()
+            if frame is None:
+                break
+            images.append(frame)
+        if not len(images):
+            raise Exception('No image found in {}'.format(filename))
+
+        w, h = images[0].get_size()
+        ifmt = images[0].get_pixel_format()
+        if ifmt != 'rgba' and ifmt != 'rgb24':
+            fmt = 'rgba'
+            sws = SWScale(w, h, ifmt, ofmt=fmt)
+            for i, image in enumerate(images):
+                images[i] = sws.scale(image)
+        else:
+            fmt = ifmt if ifmt == 'rgba' else 'rgb'
+
+        return [ImageData(w, h, fmt, img.to_memoryview()[0], source_image=img)
+                for img in images]
+
+
+# register
+ImageLoader.register(ImageLoaderFFPy)
diff --git a/kivy/core/image/img_pil.py b/kivy/core/image/img_pil.py
new file mode 100644
index 0000000..dfc062d
--- /dev/null
+++ b/kivy/core/image/img_pil.py
@@ -0,0 +1,123 @@
+'''
+PIL: PIL image loader
+'''
+
+__all__ = ('ImageLoaderPIL', )
+
+try:
+    import Image as PILImage
+except ImportError:
+    # for python3
+    from PIL import Image as PILImage
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+try:
+    # Pillow
+    PILImage.frombytes
+    PILImage.Image.tobytes
+except AttributeError:
+    # PIL
+    # monkey patch frombytes and tobytes methods, refs:
+    # https://github.com/kivy/kivy/issues/5460
+    PILImage.frombytes = PILImage.frombuffer
+    PILImage.Image.tobytes = PILImage.Image.tostring
+
+
+class ImageLoaderPIL(ImageLoaderBase):
+    '''Image loader based on the PIL library.
+
+    .. versionadded:: 1.0.8
+
+    Support for GIF animation added.
+
+    Gif animation has a lot of issues(transparency/color depths... etc).
+    In order to keep it simple, what is implemented here is what is
+    natively supported by the PIL library.
+
+    As a general rule, try to use gifs that have no transparency.
+    Gif's with transparency will work but be prepared for some
+    artifacts until transparency support is improved.
+
+    '''
+
+    @staticmethod
+    def can_save(fmt, is_bytesio):
+        if is_bytesio:
+            return False
+        return fmt in ImageLoaderPIL.extensions()
+
+    @staticmethod
+    def can_load_memory():
+        return True
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        PILImage.init()
+        return tuple((ext_with_dot[1:] for ext_with_dot in PILImage.EXTENSION))
+
+    def _img_correct(self, _img_tmp):
+        '''Convert image to the correct format and orientation.
+        '''
+        # image loader work only with rgb/rgba image
+        if _img_tmp.mode.lower() not in ('rgb', 'rgba'):
+            try:
+                imc = _img_tmp.convert('RGBA')
+            except:
+                Logger.warning(
+                    'Image: Unable to convert image to rgba (was %s)' %
+                    (_img_tmp.mode.lower()))
+                raise
+            _img_tmp = imc
+
+        return _img_tmp
+
+    def _img_read(self, im):
+        '''Read images from an animated file.
+        '''
+        im.seek(0)
+
+        # Read all images inside
+        try:
+            img_ol = None
+            while True:
+                img_tmp = im
+                img_tmp = self._img_correct(img_tmp)
+                if img_ol and (hasattr(im, 'dispose') and not im.dispose):
+                    # paste new frame over old so as to handle
+                    # transparency properly
+                    img_ol.paste(img_tmp, (0, 0), img_tmp)
+                    img_tmp = img_ol
+                img_ol = img_tmp
+                yield ImageData(img_tmp.size[0], img_tmp.size[1],
+                                img_tmp.mode.lower(), img_tmp.tobytes())
+                im.seek(im.tell() + 1)
+        except EOFError:
+            pass
+
+    def load(self, filename):
+        try:
+            im = PILImage.open(filename)
+        except:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise
+        # update internals
+        if not self._inline:
+            self.filename = filename
+        # returns an array of type ImageData len 1 if not a sequence image
+        return list(self._img_read(im))
+
+    @staticmethod
+    def save(filename, width, height, pixelfmt, pixels, flipped=False,
+             imagefmt=None):
+        image = PILImage.frombytes(pixelfmt.upper(), (width, height), pixels)
+        if flipped:
+            image = image.transpose(PILImage.FLIP_TOP_BOTTOM)
+        image.save(filename)
+        return True
+
+
+# register
+ImageLoader.register(ImageLoaderPIL)
diff --git a/kivy/core/image/img_pygame.py b/kivy/core/image/img_pygame.py
new file mode 100644
index 0000000..73a5132
--- /dev/null
+++ b/kivy/core/image/img_pygame.py
@@ -0,0 +1,119 @@
+'''
+Pygame: Pygame image loader
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('ImageLoaderPygame', )
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+from os.path import isfile
+from kivy.utils import deprecated
+
+try:
+    import pygame
+except:
+    raise
+
+
+class ImageLoaderPygame(ImageLoaderBase):
+    '''Image loader based on the PIL library'''
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, *largs, **kwargs):
+        super(ImageLoaderPygame, self).__init__(*largs, **kwargs)
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        # under OS X, i got with "pygame.error: File is not a Windows BMP
+        # file". documentation said: The image module is a required dependency
+        # of Pygame, but it only optionally supports any extended file formats.
+        # By default it can only load uncompressed BMP image
+        if pygame.image.get_extended() == 0:
+            return ('bmp', )
+        return ('jpg', 'jpeg', 'jpe', 'png', 'bmp', 'pcx', 'tga', 'tiff',
+                'tif', 'lbm', 'pbm', 'ppm', 'xpm')
+
+    @staticmethod
+    def can_save(fmt, is_bytesio):
+        if is_bytesio:
+            return False
+        return fmt in ('png', 'jpg')
+
+    @staticmethod
+    def can_load_memory():
+        return True
+
+    def load(self, filename):
+        if not filename:
+            import traceback
+            traceback.print_stack()
+            return
+        try:
+            im = None
+            if self._inline:
+                im = pygame.image.load(filename, 'x.{}'.format(self._ext))
+            elif isfile(filename):
+                with open(filename, 'rb') as fd:
+                    im = pygame.image.load(fd)
+            elif isinstance(filename, bytes):
+                try:
+                    fname = filename.decode()
+                    if isfile(fname):
+                        with open(fname, 'rb') as fd:
+                            im = pygame.image.load(fd)
+                except UnicodeDecodeError:
+                    pass
+            if im is None:
+                im = pygame.image.load(filename)
+        except:
+            # Logger.warning(type(filename)('Image: Unable to load image <%s>')
+            #               % filename)
+            raise
+
+        fmt = ''
+        if im.get_bytesize() == 3 and not im.get_colorkey():
+            fmt = 'rgb'
+        elif im.get_bytesize() == 4:
+            fmt = 'rgba'
+
+        # image loader work only with rgb/rgba image
+        if fmt not in ('rgb', 'rgba'):
+            try:
+                imc = im.convert(32)
+                fmt = 'rgba'
+            except:
+                try:
+                    imc = im.convert_alpha()
+                    fmt = 'rgba'
+                except:
+                    Logger.warning(
+                        'Image: Unable to convert image %r to rgba (was %r)' %
+                        (filename, im.fmt))
+                    raise
+            im = imc
+
+        # update internals
+        if not self._inline:
+            self.filename = filename
+        data = pygame.image.tostring(im, fmt.upper())
+        return [ImageData(im.get_width(), im.get_height(),
+                fmt, data, source=filename)]
+
+    @staticmethod
+    def save(filename, width, height, pixelfmt, pixels, flipped,
+             imagefmt=None):
+        surface = pygame.image.fromstring(
+            pixels, (width, height), pixelfmt.upper(), flipped)
+        pygame.image.save(surface, filename)
+        return True
+
+
+# register
+ImageLoader.register(ImageLoaderPygame)
diff --git a/kivy/core/image/img_sdl2.py b/kivy/core/image/img_sdl2.py
new file mode 100644
index 0000000..da684be
--- /dev/null
+++ b/kivy/core/image/img_sdl2.py
@@ -0,0 +1,66 @@
+'''
+SDL2 image loader
+=================
+'''
+
+__all__ = ('ImageLoaderSDL2', )
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+try:
+    from kivy.core.image import _img_sdl2
+except ImportError:
+    from kivy.core import handle_win_lib_import_error
+    handle_win_lib_import_error(
+        'image', 'sdl2', 'kivy.core.image._img_sdl2')
+    raise
+
+
+class ImageLoaderSDL2(ImageLoaderBase):
+    '''Image loader based on SDL2_image'''
+
+    def _ensure_ext(self):
+        _img_sdl2.init()
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        return ('bmp', 'jpg', 'jpeg', 'jpe', 'lbm', 'pcx', 'png', 'pnm',
+                'tga', 'tiff', 'webp', 'xcf', 'xpm', 'xv')
+
+    @staticmethod
+    def can_save(fmt, is_bytesio):
+        return fmt in ('jpg', 'png')
+
+    @staticmethod
+    def can_load_memory():
+        return True
+
+    def load(self, filename):
+        if self._inline:
+            data = filename.read()
+            info = _img_sdl2.load_from_memory(data)
+        else:
+            info = _img_sdl2.load_from_filename(filename)
+        if not info:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise Exception('SDL2: Unable to load image')
+
+        w, h, fmt, pixels, rowlength = info
+
+        # update internals
+        if not self._inline:
+            self.filename = filename
+        return [ImageData(
+            w, h, fmt, pixels, source=filename,
+            rowlength=rowlength)]
+
+    @staticmethod
+    def save(filename, width, height, pixelfmt, pixels, flipped, imagefmt):
+        _img_sdl2.save(filename, width, height, pixelfmt, pixels, flipped,
+                       imagefmt)
+        return True
+
+
+# register
+ImageLoader.register(ImageLoaderSDL2)
diff --git a/kivy/core/image/img_tex.py b/kivy/core/image/img_tex.py
new file mode 100644
index 0000000..187e011
--- /dev/null
+++ b/kivy/core/image/img_tex.py
@@ -0,0 +1,58 @@
+'''
+Tex: Compressed texture
+'''
+
+__all__ = ('ImageLoaderTex', )
+
+import json
+from struct import unpack
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+
+class ImageLoaderTex(ImageLoaderBase):
+
+    @staticmethod
+    def extensions():
+        return ('tex', )
+
+    def load(self, filename):
+        try:
+            fd = open(filename, 'rb')
+            if fd.read(4) != 'KTEX':
+                raise Exception('Invalid tex identifier')
+
+            headersize = unpack('I', fd.read(4))[0]
+            header = fd.read(headersize)
+            if len(header) != headersize:
+                raise Exception('Truncated tex header')
+
+            info = json.loads(header)
+            data = fd.read()
+            if len(data) != info['datalen']:
+                raise Exception('Truncated tex data')
+
+        except:
+            Logger.warning('Image: Image <%s> is corrupted' % filename)
+            raise
+
+        width, height = info['image_size']
+        tw, th = info['texture_size']
+
+        images = [data]
+        im = ImageData(width, height, str(info['format']), images[0],
+                       source=filename)
+        '''
+        if len(dds.images) > 1:
+            images = dds.images
+            images_size = dds.images_size
+            for index in range(1, len(dds.images)):
+                w, h = images_size[index]
+                data = images[index]
+                im.add_mipmap(index, w, h, data)
+        '''
+        return [im]
+
+
+# register
+ImageLoader.register(ImageLoaderTex)
diff --git a/kivy/core/spelling/__init__.py b/kivy/core/spelling/__init__.py
new file mode 100644
index 0000000..83949e5
--- /dev/null
+++ b/kivy/core/spelling/__init__.py
@@ -0,0 +1,135 @@
+'''
+Spelling
+========
+
+Provides abstracted access to a range of spellchecking backends as well as
+word suggestions. The API is inspired by enchant but other backends can be
+added that implement the same API.
+
+Spelling currently requires `python-enchant` for all platforms except
+OSX, where a native implementation exists.
+
+::
+
+    >>> from kivy.core.spelling import Spelling
+    >>> s = Spelling()
+    >>> s.list_languages()
+    ['en', 'en_CA', 'en_GB', 'en_US']
+    >>> s.select_language('en_US')
+    >>> s.suggest('helo')
+    [u'hole', u'help', u'helot', u'hello', u'halo', u'hero', u'hell', u'held',
+     u'helm', u'he-lo']
+
+'''
+
+__all__ = ('Spelling', 'SpellingBase', 'NoSuchLangError',
+           'NoLanguageSelectedError')
+
+import sys
+from kivy.core import core_select_lib
+
+
+class NoSuchLangError(Exception):
+    '''
+    Exception to be raised when a specific language could not be found.
+    '''
+    pass
+
+
+class NoLanguageSelectedError(Exception):
+    '''
+    Exception to be raised when a language-using method is called but no
+    language was selected prior to the call.
+    '''
+    pass
+
+
+class SpellingBase(object):
+    '''
+    Base class for all spelling providers.
+    Supports some abstract methods for checking words and getting suggestions.
+    '''
+
+    def __init__(self, language=None):
+        '''
+        If a `language` identifier (such as 'en_US') is provided and a matching
+        language exists, it is selected. If an identifier is provided and no
+        matching language exists, a NoSuchLangError exception is raised by
+        self.select_language().
+        If no `language` identifier is provided, we just fall back to the first
+        one that is available.
+
+        :Parameters:
+            `language`: str, defaults to None
+                If provided, indicates the language to be used. This needs
+                to be a language identifier understood by select_language(),
+                i.e. one of the options returned by list_languages().
+                If nothing is provided, the first available language is used.
+                If no language is available, NoLanguageSelectedError is raised.
+        '''
+        langs = self.list_languages()
+        try:
+            # If no language was specified, we just use the first one
+            # that is available.
+            fallback_lang = langs[0]
+        except IndexError:
+            raise NoLanguageSelectedError("No languages available!")
+        self.select_language(language or fallback_lang)
+
+    def select_language(self, language):
+        '''
+        From the set of registered languages, select the first language
+        for `language`.
+
+        :Parameters:
+            `language`: str
+                Language identifier. Needs to be one of the options returned by
+                list_languages(). Sets the language used for spell checking and
+                word suggestions.
+        '''
+        raise NotImplementedError('select_language() method not implemented '
+                                  'by abstract spelling base class!')
+
+    def list_languages(self):
+        '''
+        Return a list of all supported languages.
+        E.g. ['en', 'en_GB', 'en_US', 'de', ...]
+        '''
+        raise NotImplementedError('list_languages() is not implemented '
+                                  'by abstract spelling base class!')
+
+    def check(self, word):
+        '''
+        If `word` is a valid word in `self._language` (the currently active
+        language), returns True. If the word shouldn't be checked, returns
+        None (e.g. for ''). If it is not a valid word in `self._language`,
+        return False.
+
+        :Parameters:
+            `word`: str
+                The word to check.
+        '''
+        raise NotImplementedError('check() not implemented by abstract ' +
+                                  'spelling base class!')
+
+    def suggest(self, fragment):
+        '''
+        For a given `fragment` (i.e. part of a word or a word by itself),
+        provide corrections (`fragment` may be misspelled) or completions
+        as a list of strings.
+
+        :Parameters:
+            `fragment`: str
+                The word fragment to get suggestions/corrections for.
+                E.g. 'foo' might become 'of', 'food' or 'foot'.
+
+        '''
+        raise NotImplementedError('suggest() not implemented by abstract ' +
+                                  'spelling base class!')
+
+
+_libs = (('enchant', 'spelling_enchant', 'SpellingEnchant'), )
+if sys.platform == 'darwin':
+    _libs += (('osxappkit', 'spelling_osxappkit', 'SpellingOSXAppKit'), )
+
+Spelling = core_select_lib('spelling', _libs)
diff --git a/kivy/core/spelling/__pycache__/__init__.cpython-310.pyc b/kivy/core/spelling/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..4fb3acc
Binary files /dev/null and b/kivy/core/spelling/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/spelling/__pycache__/spelling_enchant.cpython-310.pyc b/kivy/core/spelling/__pycache__/spelling_enchant.cpython-310.pyc
new file mode 100644
index 0000000..f2c939d
Binary files /dev/null and b/kivy/core/spelling/__pycache__/spelling_enchant.cpython-310.pyc differ
diff --git a/kivy/core/spelling/__pycache__/spelling_osxappkit.cpython-310.pyc b/kivy/core/spelling/__pycache__/spelling_osxappkit.cpython-310.pyc
new file mode 100644
index 0000000..7ef6679
Binary files /dev/null and b/kivy/core/spelling/__pycache__/spelling_osxappkit.cpython-310.pyc differ
diff --git a/kivy/core/spelling/spelling_enchant.py b/kivy/core/spelling/spelling_enchant.py
new file mode 100644
index 0000000..55ed99a
--- /dev/null
+++ b/kivy/core/spelling/spelling_enchant.py
@@ -0,0 +1,50 @@
+'''
+Enchant Spelling
+================
+
+Implementation spelling backend based on enchant.
+
+.. warning:: pyenchant doesn't have dedicated build anymore for Windows/x64.
+             See https://github.com/kivy/kivy/issues/5816 for more information
+'''
+
+
+import enchant
+
+from kivy.core.spelling import SpellingBase, NoSuchLangError
+from kivy.compat import PY2
+
+
+class SpellingEnchant(SpellingBase):
+    '''
+    Spelling backend based on the enchant library.
+    '''
+
+    def __init__(self, language=None):
+        self._language = None
+        super(SpellingEnchant, self).__init__(language)
+
+    def select_language(self, language):
+        try:
+            self._language = enchant.Dict(language)
+        except enchant.DictNotFoundError:
+            err = 'Enchant Backend: No language for "%s"' % (language, )
+            raise NoSuchLangError(err)
+
+    def list_languages(self):
+        # Note: We do NOT return enchant.list_dicts because that also returns
+        #       the enchant dict objects and not only the language identifiers.
+        return enchant.list_languages()
+
+    def check(self, word):
+        if not word:
+            return None
+        return self._language.check(word)
+
+    def suggest(self, fragment):
+        suggestions = self._language.suggest(fragment)
+        # Don't show suggestions that are invalid
+        suggestions = [s for s in suggestions if self.check(s)]
+        if PY2:
+            suggestions = [s.decode('utf-8') for s in suggestions]
+        return suggestions
diff --git a/kivy/core/spelling/spelling_osxappkit.py b/kivy/core/spelling/spelling_osxappkit.py
new file mode 100644
index 0000000..2afda71
--- /dev/null
+++ b/kivy/core/spelling/spelling_osxappkit.py
@@ -0,0 +1,64 @@
+'''
+AppKit Spelling: Implements spelling backend based on OSX's spellchecking
+                 features provided by the ApplicationKit.
+
+                 NOTE:
+                    Requires pyobjc and setuptools to be installed!
+                    `sudo easy_install pyobjc setuptools`
+
+                 Developers should read:
+                    http://developer.apple.com/mac/library/documentation/
+                        Cocoa/Conceptual/SpellCheck/SpellCheck.html
+                    http://developer.apple.com/cocoa/pyobjc.html
+'''
+
+
+from AppKit import NSSpellChecker, NSMakeRange
+
+from kivy.core.spelling import SpellingBase, NoSuchLangError
+
+
+class SpellingOSXAppKit(SpellingBase):
+    '''
+    Spelling backend based on OSX's spelling features provided by AppKit.
+    '''
+
+    def __init__(self, language=None):
+        self._language = NSSpellChecker.alloc().init()
+        super(SpellingOSXAppKit, self).__init__(language)
+
+    def select_language(self, language):
+        success = self._language.setLanguage_(language)
+        if not success:
+            err = 'AppKit Backend: No language "%s" ' % (language, )
+            raise NoSuchLangError(err)
+
+    def list_languages(self):
+        return list(self._language.availableLanguages())
+
+    def check(self, word):
+        # TODO Implement this!
+        #      NSSpellChecker provides several functions that look like what we
+        #      need, but they're a) slooow and b) return a strange result.
+        #      Might be a snow leopard bug. Have to test further.
+        #      See: http://paste.pocoo.org/show/217968/
+        if not word:
+            return None
+        err = 'check() not currently supported by the OSX AppKit backend'
+        raise NotImplementedError(err)
+
+    def suggest(self, fragment):
+        l = self._language
+        # XXX Both ways below work on OSX 10.6. It has not been tested on any
+        #     other version, but it should work.
+        try:
+            # This is deprecated as of OSX 10.6, hence the try-except
+            return list(l.guessesForWord_(fragment))
+        except AttributeError:
+            # From 10.6 onwards you're supposed to do it like this:
+            checkrange = NSMakeRange(0, len(fragment))
+            g = l.\
+                guessesForWordRange_inString_language_inSpellDocumentWithTag_(
+                    checkrange, fragment, l.language(), 0)
+            # Right, this was much easier, Apple! :-)
+            return list(g)
diff --git a/kivy/core/text/__init__.py b/kivy/core/text/__init__.py
new file mode 100644
index 0000000..fb1e2ee
--- /dev/null
+++ b/kivy/core/text/__init__.py
@@ -0,0 +1,1016 @@
+'''
+Text
+====
+
+An abstraction of text creation. Depending of the selected backend, the
+accuracy of text rendering may vary.
+
+.. versionchanged:: 1.10.1
+    :meth:`LabelBase.find_base_direction` added.
+
+.. versionchanged:: 1.5.0
+    :attr:`LabelBase.line_height` added.
+
+.. versionchanged:: 1.0.7
+    The :class:`LabelBase` does not generate any texture if the text has a
+    width <= 1.
+
+This is the backend layer for rendering text with different text providers,
+you should only be using this directly if your needs aren't fulfilled by the
+:class:`~kivy.uix.label.Label`.
+
+Usage example::
+
+    from kivy.core.text import Label as CoreLabel
+
+    ...
+    ...
+    my_label = CoreLabel()
+    my_label.text = 'hello'
+    # the label is usually not drawn until needed, so force it to draw.
+    my_label.refresh()
+    # Now access the texture of the label and use it wherever and
+    # however you may please.
+    hello_texture = my_label.texture
+
+
+Font Context Manager
+====================
+
+A font context is a namespace where multiple fonts are loaded; if a font is
+missing a glyph needed to render text, it can fall back to a different font in
+the same context. The font context manager can be used to query and manipulate
+the state of font contexts when using the Pango text provider (no other
+provider currently implements it).
+
+.. versionadded:: 1.11.0
+
+.. warning:: This feature requires the Pango text provider.
+
+Font contexts can be created automatically by :class:`kivy.uix.label.Label` or
+:class:`kivy.uix.textinput.TextInput`; if a non-existent context is used in
+one of these classes, it will be created automatically, or if a font file is
+specified without a context (this creates an isolated context, without
+support for fallback).
+
+Usage example::
+
+    from kivy.uix.label import Label
+    from kivy.core.text import FontContextManager as FCM
+
+    # Create a font context containing system fonts + one custom TTF
+    FCM.create('system://myapp')
+    family = FCM.add_font('/path/to/file.ttf')
+
+    # These are now interchangeable ways to refer to the custom font:
+    lbl1 = Label(font_context='system://myapp', family_name=family)
+    lbl2 = Label(font_context='system://myapp', font_name='/path/to/file.ttf')
+
+    # You could also refer to a system font by family, since this is a
+    # system:// font context
+    lbl3 = Label(font_context='system://myapp', family_name='Arial')
+'''
+
+__all__ = ('LabelBase', 'Label',
+           'FontContextManagerBase', 'FontContextManager')
+
+import re
+import os
+from ast import literal_eval
+from functools import partial
+from copy import copy
+from kivy import kivy_data_dir
+from kivy.config import Config
+from kivy.utils import platform
+from kivy.graphics.texture import Texture
+from kivy.core import core_select_lib
+from kivy.core.text.text_layout import layout_text, LayoutWord
+from kivy.resources import resource_find, resource_add_path
+from kivy.compat import PY2
+from kivy.setupconfig import USE_SDL2, USE_PANGOFT2
+
+
+if 'KIVY_DOC' not in os.environ:
+    _default_font_paths = literal_eval(Config.get('kivy', 'default_font'))
+    DEFAULT_FONT = _default_font_paths.pop(0)
+else:
+    DEFAULT_FONT = None
+
+FONT_REGULAR = 0
+FONT_ITALIC = 1
+FONT_BOLD = 2
+FONT_BOLDITALIC = 3
+
+whitespace_pat = re.compile('( +)')
+
+
+class LabelBase(object):
+    '''Core text label.
+    This is the abstract class used by different backends to render text.
+
+    .. warning::
+        The core text label can't be changed at runtime. You must recreate one.
+
+    :Parameters:
+        `font_size`: int, defaults to 12
+            Font size of the text
+        `font_context`: str, defaults to None
+            Context for the specified font (see :class:`kivy.uix.label.Label`
+            for details). `None` will autocreate an isolated context named
+            after the resolved font file.
+        `font_name`: str, defaults to DEFAULT_FONT
+            Font name of the text
+        `font_family`: str, defaults to None
+            Font family name to request for drawing, this can only be used
+            with `font_context`.
+        `bold`: bool, defaults to False
+            Activate "bold" text style
+        `italic`: bool, defaults to False
+            Activate "italic" text style
+        `text_size`: tuple, defaults to (None, None)
+            Add constraint to render the text (inside a bounding box).
+            If no size is given, the label size will be set to the text size.
+        `padding`: float, defaults to None
+            If it's a float, it will set padding_x and padding_y
+        `padding_x`: float, defaults to 0.0
+            Left/right padding
+        `padding_y`: float, defaults to 0.0
+            Top/bottom padding
+        `halign`: str, defaults to "left"
+            Horizontal text alignment inside the bounding box
+        `valign`: str, defaults to "bottom"
+            Vertical text alignment inside the bounding box
+        `shorten`: bool, defaults to False
+            Indicate whether the label should attempt to shorten its textual
+            contents as much as possible if a `size` is given.
+            Setting this to True without an appropriately set size will lead to
+            unexpected results.
+        `shorten_from`: str, defaults to `center`
+            The side from which we should shorten the text from, can be left,
+            right, or center. E.g. if left, the ellipsis will appear towards
+            the left side and it will display as much text starting from the
+            right as possible.
+        `split_str`: string, defaults to `' '` (space)
+            The string to use to split the words by when shortening. If empty,
+            we can split after every character filling up the line as much as
+            possible.
+        `max_lines`: int, defaults to 0 (unlimited)
+            If set, this indicate how maximum line are allowed to render the
+            text. Works only if a limitation on text_size is set.
+        `mipmap`: bool, defaults to False
+            Create a mipmap for the texture
+        `strip`: bool, defaults to False
+            Whether each row of text has its leading and trailing spaces
+            stripped. If `halign` is `justify` it is implicitly True.
+        `strip_reflow`: bool, defaults to True
+            Whether text that has been reflowed into a second line should
+            be stripped, even if `strip` is False. This is only in effect when
+            `size_hint_x` is not None, because otherwise lines are never
+            split.
+        `unicode_errors`: str, defaults to `'replace'`
+            How to handle unicode decode errors. Can be `'strict'`, `'replace'`
+            or `'ignore'`.
+        `outline_width`: int, defaults to None
+            Width in pixels for the outline.
+        `outline_color`: tuple, defaults to (0, 0, 0)
+            Color of the outline.
+        `font_features`: str, defaults to None
+            OpenType font features in CSS format (Pango only)
+        `base_direction`: str, defaults to None (auto)
+            Text direction, one of `None`, `'ltr'`, `'rtl'`, `'weak_ltr'`,
+            or `'weak_rtl'` (Pango only)
+        `text_language`: str, defaults to None (user locale)
+            RFC-3066 format language tag as a string (Pango only)
+
+    .. versionchanged:: 1.10.1
+        `font_context`, `font_family`, `font_features`, `base_direction`
+        and `text_language` were added.
+
+    .. versionchanged:: 1.10.0
+        `outline_width` and `outline_color` were added.
+
+    .. versionchanged:: 1.9.0
+        `strip`, `strip_reflow`, `shorten_from`, `split_str`, and
+        `unicode_errors` were added.
+
+    .. versionchanged:: 1.9.0
+        `padding_x` and `padding_y` has been fixed to work as expected.
+        In the past, the text was padded by the negative of their values.
+
+    .. versionchanged:: 1.8.0
+        `max_lines` parameters has been added.
+
+    .. versionchanged:: 1.0.8
+        `size` have been deprecated and replaced with `text_size`.
+
+    .. versionchanged:: 1.0.7
+        The `valign` is now respected. This wasn't the case previously
+        so you might have an issue in your application if you have not
+        considered this.
+
+    '''
+
+    __slots__ = ('options', 'texture', '_label', '_text_size')
+
+    _cached_lines = []
+
+    _fonts = {}
+
+    _fonts_cache = {}
+
+    _fonts_dirs = []
+
+    _font_dirs_files = []
+
+    _texture_1px = None
+
+    _font_family_support = False
+
+    def __init__(
+        self, text='', font_size=12, font_name=DEFAULT_FONT, bold=False,
+        italic=False, underline=False, strikethrough=False, font_family=None,
+        halign='left', valign='bottom', shorten=False,
+        text_size=None, mipmap=False, color=None, line_height=1.0, strip=False,
+        strip_reflow=True, shorten_from='center', split_str=' ',
+        unicode_errors='replace',
+        font_hinting='normal', font_kerning=True, font_blended=True,
+        outline_width=None, outline_color=None, font_context=None,
+        font_features=None, base_direction=None, text_language=None,
+        **kwargs):
+
+        # Include system fonts_dir in resource paths.
+        # This allows us to specify a font from those dirs.
+        LabelBase.get_system_fonts_dir()
+
+        options = {'text': text, 'font_size': font_size,
+                   'font_name': font_name, 'bold': bold, 'italic': italic,
+                   'underline': underline, 'strikethrough': strikethrough,
+                   'font_family': font_family,
+                   'halign': halign, 'valign': valign, 'shorten': shorten,
+                   'mipmap': mipmap, 'line_height': line_height,
+                   'strip': strip, 'strip_reflow': strip_reflow,
+                   'shorten_from': shorten_from, 'split_str': split_str,
+                   'unicode_errors': unicode_errors,
+                   'font_hinting': font_hinting,
+                   'font_kerning': font_kerning,
+                   'font_blended': font_blended,
+                   'outline_width': outline_width,
+                   'font_context': font_context,
+                   'font_features': font_features,
+                   'base_direction': base_direction,
+                   'text_language': text_language}
+
+        kwargs_get = kwargs.get
+        options['color'] = color or (1, 1, 1, 1)
+        options['outline_color'] = outline_color or (0, 0, 0, 1)
+        options['padding'] = kwargs_get('padding', (0, 0))
+        if not isinstance(options['padding'], (list, tuple)):
+            options['padding'] = (options['padding'], options['padding'])
+        options['padding_x'] = kwargs_get('padding_x', options['padding'][0])
+        options['padding_y'] = kwargs_get('padding_y', options['padding'][1])
+
+        if 'size' in kwargs:
+            options['text_size'] = kwargs['size']
+        else:
+            if text_size is None:
+                options['text_size'] = (None, None)
+            else:
+                options['text_size'] = text_size
+
+        self._text_size = options['text_size']
+        self._text = options['text']
+        self._internal_size = 0, 0  # the real computed text size (inclds pad)
+        self._cached_lines = []
+
+        self.options = options
+        self.texture = None
+        self.is_shortened = False
+        self.resolve_font_name()
+
+    @staticmethod
+    def register(name, fn_regular, fn_italic=None, fn_bold=None,
+                 fn_bolditalic=None):
+        '''Register an alias for a Font.
+
+        .. versionadded:: 1.1.0
+
+        If you're using a ttf directly, you might not be able to use the
+        bold/italic properties of
+        the ttf version. If the font is delivered in multiple files
+        (one regular, one italic and one bold), then you need to register these
+        files and use the alias instead.
+
+        All the fn_regular/fn_italic/fn_bold parameters are resolved with
+        :func:`kivy.resources.resource_find`. If fn_italic/fn_bold are None,
+        fn_regular will be used instead.
+        '''
+
+        if fn_regular is None:
+            raise ValueError("font_regular cannot be None")
+
+        fonts = []
+
+        for font_type in fn_regular, fn_italic, fn_bold, fn_bolditalic:
+            if font_type is not None:
+                font = resource_find(font_type)
+
+                if font is None:
+                    raise IOError('File {0} not found'.format(font_type))
+                else:
+                    fonts.append(font)
+            else:
+                fonts.append(fonts[0])  # add regular font to list again
+
+        LabelBase._fonts[name] = tuple(fonts)
+
+    def resolve_font_name(self):
+        options = self.options
+        fontname = options['font_name']
+        fonts = self._fonts
+        fontscache = self._fonts_cache
+
+        if self._font_family_support and options['font_family']:
+            options['font_name_r'] = None
+            return
+
+        # is the font registered?
+        if fontname in fonts:
+            # return the preferred font for the current bold/italic combination
+            italic = int(options['italic'])
+            if options['bold']:
+                bold = FONT_BOLD
+            else:
+                bold = FONT_REGULAR
+
+            options['font_name_r'] = fonts[fontname][italic | bold]
+
+        elif fontname in fontscache:
+            options['font_name_r'] = fontscache[fontname]
+        else:
+            filename = resource_find(fontname)
+            if not filename and not fontname.endswith('.ttf'):
+                fontname = '{}.ttf'.format(fontname)
+                filename = resource_find(fontname)
+
+            if filename is None:
+                # XXX for compatibility, check directly in the data dir
+                filename = pep8_fn = os.path.join(kivy_data_dir, fontname)
+                if not os.path.exists(pep8_fn) or not os.path.isfile(pep8_fn):
+                    raise IOError('Label: File %r not found' % fontname)
+            fontscache[fontname] = filename
+            options['font_name_r'] = filename
+
+    @staticmethod
+    def get_system_fonts_dir():
+        '''Return the directories used by the system for fonts.
+        '''
+        if LabelBase._fonts_dirs:
+            return LabelBase._fonts_dirs
+
+        fdirs = []
+        if platform == 'linux':
+            fdirs = [
+                '/usr/share/fonts', '/usr/local/share/fonts',
+                os.path.expanduser('~/.fonts'),
+                os.path.expanduser('~/.local/share/fonts')]
+        elif platform == 'macosx':
+            fdirs = ['/Library/Fonts', '/System/Library/Fonts',
+                     os.path.expanduser('~/Library/Fonts')]
+        elif platform == 'win':
+            fdirs = [os.path.join(os.environ['SYSTEMROOT'], 'Fonts')]
+        elif platform == 'ios':
+            fdirs = ['/System/Library/Fonts']
+        elif platform == 'android':
+            fdirs = ['/system/fonts']
+        else:
+            raise Exception("Unknown platform: {}".format(platform))
+
+        fdirs.append(os.path.join(kivy_data_dir, 'fonts'))
+        # register the font dirs
+        rdirs = []
+        _font_dir_files = []
+        for fdir in fdirs:
+            for _dir, dirs, files in os.walk(fdir):
+                _font_dir_files.extend(files)
+                resource_add_path(_dir)
+                rdirs.append(_dir)
+        LabelBase._fonts_dirs = rdirs
+        LabelBase._font_dirs_files = _font_dir_files
+
+        return rdirs
+
+    def get_extents(self, text):
+        '''Return a tuple (width, height) indicating the size of the specified
+        text'''
+        return (0, 0)
+
+    def get_cached_extents(self):
+        '''Returns a cached version of the :meth:`get_extents` function.
+
+        ::
+
+            >>> func = self._get_cached_extents()
+            >>> func
+            <built-in method size of pygame.font.Font object at 0x01E45650>
+            >>> func('a line')
+            (36, 18)
+
+        .. warning::
+
+            This method returns a size measuring function that is valid
+            for the font settings used at the time :meth:`get_cached_extents`
+            was called. Any change in the font settings will render the
+            returned function incorrect. You should only use this if you know
+            what you're doing.
+
+        .. versionadded:: 1.9.0
+        '''
+        return self.get_extents
+
+    def _render_begin(self):
+        pass
+
+    def _render_text(self, text, x, y):
+        pass
+
+    def _render_end(self):
+        pass
+
+    def shorten(self, text, margin=2):
+        ''' Shortens the text to fit into a single line by the width specified
+        by :attr:`text_size` [0]. If :attr:`text_size` [0] is None, it returns
+        text text unchanged.
+
+        :attr:`split_str` and :attr:`shorten_from` determines how the text is
+        shortened.
+
+        :params:
+
+            `text` str, the text to be shortened.
+            `margin` int, the amount of space to leave between the margins
+            and the text. This is in addition to :attr:`padding_x`.
+
+        :returns:
+            the text shortened to fit into a single line.
+        '''
+        textwidth = self.get_cached_extents()
+        uw = self.text_size[0]
+        if uw is None or not text:
+            return text
+
+        opts = self.options
+        uw = max(0, int(uw - opts['padding_x'] * 2 - margin))
+        # if larger, it won't fit so don't even try extents
+        chr = type(text)
+        text = text.replace(chr('\n'), chr(' '))
+        if len(text) <= uw and textwidth(text)[0] <= uw:
+            return text
+        c = opts['split_str']
+        offset = 0 if len(c) else 1
+        dir = opts['shorten_from'][0]
+        elps = textwidth('...')[0]
+        if elps > uw:
+            self.is_shortened = True
+            if textwidth('..')[0] <= uw:
+                return '..'
+            else:
+                return '.'
+        uw -= elps
+
+        f = partial(text.find, c)
+        f_rev = partial(text.rfind, c)
+        # now find the first and last word
+        e1, s2 = f(), f_rev()
+
+        if dir != 'l':  # center or right
+            # no split, or the first word doesn't even fit
+            if e1 != -1:
+                l1 = textwidth(text[:e1])[0]
+                l2 = textwidth(text[s2 + 1:])[0]
+            if e1 == -1 or l1 + l2 > uw:
+                self.is_shortened = True
+                if len(c):
+                    opts['split_str'] = ''
+                    res = self.shorten(text, margin)
+                    opts['split_str'] = c
+                    return res
+                # at this point we do char by char so e1 must be zero
+                if l1 <= uw:
+                    return chr('{0}...').format(text[:e1])
+                return chr('...')
+
+            # both word fits, and there's at least on split_str
+            if s2 == e1:  # there's only on split_str
+                self.is_shortened = True
+                return chr('{0}...{1}').format(text[:e1], text[s2 + 1:])
+
+            # both the first and last word fits, and they start/end at diff pos
+            if dir == 'r':
+                ee1 = f(e1 + 1)
+                while l2 + textwidth(text[:ee1])[0] <= uw:
+                    e1 = ee1
+                    if e1 == s2:
+                        break
+                    ee1 = f(e1 + 1)
+            else:
+                while True:
+                    if l1 <= l2:
+                        ee1 = f(e1 + 1)
+                        l1 = textwidth(text[:ee1])[0]
+                        if l2 + l1 > uw:
+                            break
+                        e1 = ee1
+                        if e1 == s2:
+                            break
+                    else:
+                        ss2 = f_rev(0, s2 - offset)
+                        l2 = textwidth(text[ss2 + 1:])[0]
+                        if l2 + l1 > uw:
+                            break
+                        s2 = ss2
+                        if e1 == s2:
+                            break
+        else:  # left
+            # no split, or the last word doesn't even fit
+            if s2 != -1:
+                l2 = textwidth(text[s2 + (1 if len(c) else -1):])[0]
+                l1 = textwidth(text[:max(0, e1)])[0]
+            # if split_str
+            if s2 == -1 or l2 + l1 > uw:
+                self.is_shortened = True
+                if len(c):
+                    opts['split_str'] = ''
+                    res = self.shorten(text, margin)
+                    opts['split_str'] = c
+                    return res
+
+                return chr('...')
+
+            # both word fits, and there's at least on split_str
+            if s2 == e1:  # there's only on split_str
+                self.is_shortened = True
+                return chr('{0}...{1}').format(text[:e1], text[s2 + 1:])
+
+            # both the first and last word fits, and they start/end at diff pos
+            ss2 = f_rev(0, s2 - offset)
+            while l1 + textwidth(text[ss2 + 1:])[0] <= uw:
+                s2 = ss2
+                if s2 == e1:
+                    break
+                ss2 = f_rev(0, s2 - offset)
+
+        self.is_shortened = True
+        return chr('{0}...{1}').format(text[:e1], text[s2 + 1:])
+
+    def _default_line_options(self, lines):
+        for line in lines:
+            if len(line.words):  # get opts from first line, first word
+                return line.words[0].options
+        return None
+
+    def clear_texture(self):
+        self._render_begin()
+        data = self._render_end()
+        assert(data)
+        if data is not None and data.width > 1:
+            self.texture.blit_data(data)
+        return
+
+    # FIXME: This should possibly use a Config value, and possibly we should
+    #        expose pango_unichar_direction() / pango_bidi_type_for_unichar()
+    @staticmethod
+    def find_base_direction(text):
+        '''Searches a string the first character that has a strong direction,
+        according to the Unicode bidirectional algorithm. Returns `None` if
+        the base direction cannot be determined, or one of `'ltr'` or `'rtl'`.
+
+        .. versionadded: 1.10.1
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        return 'ltr'
+
+    def render_lines(self, lines, options, render_text, y, size):
+        get_extents = self.get_cached_extents()
+        uw, uh = options['text_size']
+        xpad = options['padding_x']
+        if uw is not None:
+            uww = uw - 2 * xpad  # real width of just text
+        w = size[0]
+        sw = options['space_width']
+        halign = options['halign']
+        split = re.split
+        find_base_dir = self.find_base_direction
+        cur_base_dir = options['base_direction']
+
+        for layout_line in lines:  # for plain label each line has only one str
+            lw, lh = layout_line.w, layout_line.h
+            line = ''
+            assert len(layout_line.words) < 2
+            if len(layout_line.words):
+                last_word = layout_line.words[0]
+                line = last_word.text
+                if not cur_base_dir:
+                    cur_base_dir = find_base_dir(line)
+            x = xpad
+            if halign == 'auto':
+                if cur_base_dir and 'rtl' in cur_base_dir:
+                    x = max(0, int(w - lw - xpad))  # right-align RTL text
+            elif halign == 'center':
+                x = int((w - lw) / 2.)
+            elif halign == 'right':
+                x = max(0, int(w - lw - xpad))
+
+            # right left justify
+            # divide left over space between `spaces`
+            # TODO implement a better method of stretching glyphs?
+            if (uw is not None and halign == 'justify' and line and not
+                    layout_line.is_last_line):
+                # number spaces needed to fill, and remainder
+                n, rem = divmod(max(uww - lw, 0), sw)
+                n = int(n)
+                words = None
+                if n or rem:
+                    # there's no trailing space when justify is selected
+                    words = split(whitespace_pat, line)
+                if words is not None and len(words) > 1:
+                    space = type(line)(' ')
+                    # words: every even index is spaces, just add ltr n spaces
+                    for i in range(n):
+                        idx = (2 * i + 1) % (len(words) - 1)
+                        words[idx] = words[idx] + space
+                    if rem:
+                        # render the last word at the edge, also add it to line
+                        ext = get_extents(words[-1])
+                        word = LayoutWord(last_word.options, ext[0], ext[1],
+                                          words[-1])
+                        layout_line.words.append(word)
+                        last_word.lw = uww - ext[0]  # word was stretched
+                        render_text(words[-1], x + last_word.lw, y)
+                        last_word.text = line = ''.join(words[:-2])
+                    else:
+                        last_word.lw = uww  # word was stretched
+                        last_word.text = line = ''.join(words)
+                    layout_line.w = uww  # the line occupies full width
+
+            if len(line):
+                layout_line.x = x
+                layout_line.y = y
+                render_text(line, x, y)
+            y += lh
+        return y
+
+    def _render_real(self):
+        lines = self._cached_lines
+        options = self._default_line_options(lines)
+        if options is None:  # there was no text to render
+            return self.clear_texture()
+
+        old_opts = self.options
+        ih = self._internal_size[1]  # the real size of text, not texture
+        size = self.size
+        valign = options['valign']
+
+        y = ypad = options['padding_y']  # pos in the texture
+        if valign == 'bottom':
+            y = size[1] - ih + ypad
+        elif valign == 'middle' or valign == 'center':
+            y = int((size[1] - ih) / 2 + ypad)
+
+        self._render_begin()
+        self.render_lines(lines, options, self._render_text, y, size)
+
+        # get data from provider
+        data = self._render_end()
+        assert(data)
+        self.options = old_opts
+
+        # If the text is 1px width, usually, the data is black.
+        # Don't blit that kind of data, otherwise, you have a little black bar.
+        if data is not None and data.width > 1:
+            self.texture.blit_data(data)
+
+    def render(self, real=False):
+        '''Return a tuple (width, height) to create the image
+        with the user constraints. (width, height) includes the padding.
+        '''
+        if real:
+            return self._render_real()
+
+        options = copy(self.options)
+        options['space_width'] = self.get_extents(' ')[0]
+        options['strip'] = strip = (options['strip'] or
+                                    options['halign'] == 'justify')
+        uw, uh = options['text_size'] = self._text_size
+        text = self.text
+        if strip:
+            text = text.strip()
+
+        self.is_shortened = False
+        if uw is not None and options['shorten']:
+            text = self.shorten(text)
+
+        self._cached_lines = lines = []
+        if not text:
+            return 0, 0
+
+        if uh is not None and (options['valign'] == 'middle' or
+                               options['valign'] == 'center'):
+            center = -1  # pos of newline
+            if len(text) > 1:
+                middle = int(len(text) // 2)
+                l, r = text.rfind('\n', 0, middle), text.find('\n', middle)
+                if l != -1 and r != -1:
+                    center = l if center - l <= r - center else r
+                elif l != -1:
+                    center = l
+                elif r != -1:
+                    center = r
+            # if a newline split text, render from center down and up til uh
+            if center != -1:
+                # layout from center down until half uh
+                w, h, clipped = layout_text(text[center + 1:], lines, (0, 0),
+                (uw, uh / 2), options, self.get_cached_extents(), True, True)
+                # now layout from center upwards until uh is reached
+                w, h, clipped = layout_text(text[:center + 1], lines, (w, h),
+                (uw, uh), options, self.get_cached_extents(), False, True)
+            else:  # if there's no new line, layout everything
+                w, h, clipped = layout_text(text, lines, (0, 0), (uw, None),
+                options, self.get_cached_extents(), True, True)
+        else:  # top or bottom
+            w, h, clipped = layout_text(text, lines, (0, 0), (uw, uh), options,
+                self.get_cached_extents(), options['valign'] == 'top', True)
+        self._internal_size = w, h
+        if uw:
+            w = uw
+        if uh:
+            h = uh
+        if h > 1 and w < 2:
+            w = 2
+        return int(w), int(h)
+
+    def _texture_refresh(self, *l):
+        self.refresh()
+
+    def _texture_fill(self, texture):
+        # second pass, render for real
+        self.render(real=True)
+
+    def refresh(self):
+        '''Force re-rendering of the text
+        '''
+        self.resolve_font_name()
+
+        # first pass, calculating width/height
+        sz = self.render()
+        self._size_texture = sz
+        self._size = (sz[0], sz[1])
+
+        # if no text are rendered, return nothing.
+        width, height = self._size
+        if width <= 1 or height <= 1:
+            self.texture = self.texture_1px
+            return
+
+        # create a delayed texture
+        texture = self.texture
+        if texture is None or \
+                width != texture.width or \
+                height != texture.height:
+            texture = Texture.create(size=(width, height),
+                                     mipmap=self.options['mipmap'],
+                                     callback=self._texture_fill)
+            texture.flip_vertical()
+            texture.add_reload_observer(self._texture_refresh)
+            self.texture = texture
+        else:
+            texture.ask_update(self._texture_fill)
+
+    def _get_text(self):
+        return self._text
+
+    def _set_text(self, text):
+        if text != self._text:
+            self._text = text
+
+    text = property(_get_text, _set_text, doc='Get/Set the text')
+    label = property(_get_text, _set_text, doc='Get/Set the text')
+
+    @property
+    def texture_1px(self):
+        if LabelBase._texture_1px is None:
+            tex = Texture.create(size=(1, 1), colorfmt='rgba')
+            tex.blit_buffer(b'\x00\x00\x00\x00', colorfmt='rgba')
+            LabelBase._texture_1px = tex
+        return LabelBase._texture_1px
+
+    @property
+    def size(self):
+        return self._size
+
+    @property
+    def width(self):
+        return self._size[0]
+
+    @property
+    def height(self):
+        return self._size[1]
+
+    @property
+    def content_width(self):
+        '''Return the content width; i.e. the width of the text without
+        any padding.'''
+        if self.texture is None:
+            return 0
+        return self.texture.width - 2 * self.options['padding_x']
+
+    @property
+    def content_height(self):
+        '''Return the content height; i.e. the height of the text without
+        any padding.'''
+        if self.texture is None:
+            return 0
+        return self.texture.height - 2 * self.options['padding_y']
+
+    @property
+    def content_size(self):
+        '''Return the content size (width, height)'''
+        if self.texture is None:
+            return (0, 0)
+        return (self.content_width, self.content_height)
+
+    @property
+    def fontid(self):
+        '''Return a unique id for all font parameters'''
+        return str([self.options[x] for x in (
+            'font_size', 'font_name_r', 'bold',
+            'italic', 'underline', 'strikethrough')])
+
+    def _get_text_size(self):
+        return self._text_size
+
+    def _set_text_size(self, x):
+        self._text_size = x
+
+    text_size = property(_get_text_size, _set_text_size,
+                         doc='''Get/set the (width, height) of the '
+                         'contrained rendering box''')
+
+    usersize = property(_get_text_size, _set_text_size,
+                        doc='''(deprecated) Use text_size instead.''')
+
+
+class FontContextManagerBase(object):
+    @staticmethod
+    def create(font_context):
+        '''Create a font context, you must specify a unique name (string).
+        Returns `True` on success and `False` on failure.
+
+        If `font_context` starts with one of the reserved words `'system://'`,
+        `'directory://'`, `'fontconfig://'` or `'systemconfig://'`, the context
+        is setup accordingly (exact results of this depends on your platform,
+        environment and configuration).
+
+        * `'system://'` loads the default system's FontConfig configuration
+          and all fonts (usually including user fonts).
+        * `directory://` contexts preload a directory of font files (specified
+          in the context name), `systemconfig://` loads the system's FontConfig
+          configuration (but no fonts), and `fontconfig://` loads FontConfig
+          configuration file (specified in the context name!). These are for
+          advanced users only, check the source code and FontConfig
+          documentation for details.
+        * Fonts automatically loaded to an isolated context (ie when no
+          font context was specified) start with `'isolated://'`. This has
+          no special effect, and only serves to help you identify them in
+          the results returned from :meth:`list`.
+        * Any other string is a context that will only draw with the font
+          file(s) you explicitly add to it.
+
+        .. versionadded:: 1.11.0
+
+        .. note::
+            Font contexts are created automatically by specifying a name in the
+            `font_context` property of :class:`kivy.uix.label.Label` or
+            :class:`kivy.uix.textinput.TextInput`. They are also auto-created
+            by :meth:`add_font` by default, so you normally don't need to
+            call this directly.
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        raise NotImplementedError("No font_context support in text provider")
+
+    @staticmethod
+    def exists(font_context):
+        '''Returns True if a font context with the given name exists.
+
+        .. versionadded:: 1.11.0
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        raise NotImplementedError("No font_context support in text provider")
+
+    @staticmethod
+    def destroy(font_context):
+        '''Destroy a named font context (if it exists)
+
+        .. versionadded:: 1.11.0
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        raise NotImplementedError("No font_context support in text provider")
+
+    @staticmethod
+    def list():
+        '''Returns a list of `bytes` objects, each representing a cached font
+        context name. Note that entries that start with `isolated://` were
+        autocreated by loading a font file with no font_context specified.
+
+        .. versionadded:: 1.11.0
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        raise NotImplementedError("No font_context support in text provider")
+
+    @staticmethod
+    def list_families(font_context):
+        '''Returns a list of `bytes` objects, each representing a font family
+        name that is available in the given `font_context`.
+
+        .. versionadded:: 1.11.0
+
+        .. note::
+            Pango adds static "Serif", "Sans" and "Monospace" to the list in
+            current versions, even if only a single custom font file is added
+            to the context.
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        raise NotImplementedError("No font_context support in text provider")
+
+    @staticmethod
+    def list_custom(font_context):
+        '''Returns a dictionary representing all the custom-loaded fonts in
+        the context. The key is a `bytes` object representing the full path
+        to the font file, the value is a `bytes` object representing the font
+        family name used to request drawing with the font.
+
+        .. versionadded:: 1.11.0
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        raise NotImplementedError("No font_context support in text provider")
+
+    @staticmethod
+    def add_font(font_context, filename, autocreate=True, family=None):
+        '''Add a font file to a named font context. If `autocreate` is true,
+        the context will be created if it does not exist (this is the
+        default). You can specify the `family` argument (string) to skip
+        auto-detecting the font family name.
+
+        .. warning::
+
+            The `family` argument is slated for removal if the underlying
+            implementation can be fixed, It is offered as a way to optimize
+            startup time for deployed applications (it avoids opening the
+            file with FreeType2 to determine its family name). To use this,
+            first load the font file without specifying `family`, and
+            hardcode the returned (autodetected) `family` value in your font
+            context initialization.
+
+        .. versionadded:: 1.11.0
+
+        .. note:: This feature requires the Pango text provider.
+        '''
+        raise NotImplementedError("No font_context support in text provider")
+
+
+# Load the appropriate provider
+label_libs = []
+if USE_PANGOFT2:
+    label_libs += [('pango', 'text_pango', 'LabelPango')]
+
+if USE_SDL2:
+    label_libs += [('sdl2', 'text_sdl2', 'LabelSDL2')]
+else:
+    label_libs += [('pygame', 'text_pygame', 'LabelPygame')]
+label_libs += [
+    ('pil', 'text_pil', 'LabelPIL')]
+Text = Label = core_select_lib('text', label_libs)
+
+if 'KIVY_DOC' not in os.environ:
+    if not Label:
+        from kivy.logger import Logger
+        import sys
+        Logger.critical('App: Unable to get a Text provider, abort.')
+        sys.exit(1)
+
+    # FIXME: Better way to do this
+    if Label.__name__ == 'LabelPango':
+        from kivy.core.text.text_pango import PangoFontContextManager
+        FontContextManager = PangoFontContextManager()
+    else:
+        FontContextManager = FontContextManagerBase()
+
+
+# For the first initialization, register the default font
+    Label.register(DEFAULT_FONT, *_default_font_paths)
diff --git a/kivy/core/text/__pycache__/__init__.cpython-310.pyc b/kivy/core/text/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..1a5d71b
Binary files /dev/null and b/kivy/core/text/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/text/__pycache__/markup.cpython-310.pyc b/kivy/core/text/__pycache__/markup.cpython-310.pyc
new file mode 100644
index 0000000..b43f22a
Binary files /dev/null and b/kivy/core/text/__pycache__/markup.cpython-310.pyc differ
diff --git a/kivy/core/text/__pycache__/text_pango.cpython-310.pyc b/kivy/core/text/__pycache__/text_pango.cpython-310.pyc
new file mode 100644
index 0000000..7f063ac
Binary files /dev/null and b/kivy/core/text/__pycache__/text_pango.cpython-310.pyc differ
diff --git a/kivy/core/text/__pycache__/text_pil.cpython-310.pyc b/kivy/core/text/__pycache__/text_pil.cpython-310.pyc
new file mode 100644
index 0000000..fa3b149
Binary files /dev/null and b/kivy/core/text/__pycache__/text_pil.cpython-310.pyc differ
diff --git a/kivy/core/text/__pycache__/text_pygame.cpython-310.pyc b/kivy/core/text/__pycache__/text_pygame.cpython-310.pyc
new file mode 100644
index 0000000..926d6a5
Binary files /dev/null and b/kivy/core/text/__pycache__/text_pygame.cpython-310.pyc differ
diff --git a/kivy/core/text/__pycache__/text_sdl2.cpython-310.pyc b/kivy/core/text/__pycache__/text_sdl2.cpython-310.pyc
new file mode 100644
index 0000000..cedc15f
Binary files /dev/null and b/kivy/core/text/__pycache__/text_sdl2.cpython-310.pyc differ
diff --git a/kivy/core/text/_text_sdl2.cpython-310-x86_64-linux-gnu.so b/kivy/core/text/_text_sdl2.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..4425e4f
Binary files /dev/null and b/kivy/core/text/_text_sdl2.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/core/text/markup.py b/kivy/core/text/markup.py
new file mode 100644
index 0000000..3be79ac
--- /dev/null
+++ b/kivy/core/text/markup.py
@@ -0,0 +1,879 @@
+'''
+Text Markup
+===========
+
+.. versionadded:: 1.1.0
+
+.. versionchanged:: 1.10.1
+
+    Added `font_context`, `font_features` and `text_language` (Pango only)
+
+We provide a simple text-markup for inline text styling. The syntax look the
+same as the `BBCode <http://en.wikipedia.org/wiki/BBCode>`_.
+
+A tag is defined as ``[tag]``, and should have a corresponding
+``[/tag]`` closing tag. For example::
+
+    [b]Hello [color=ff0000]world[/color][/b]
+
+The following tags are available:
+
+``[b][/b]``
+    Activate bold text
+``[i][/i]``
+    Activate italic text
+``[u][/u]``
+    Underlined text
+``[s][/s]``
+    Strikethrough text
+``[font=<str>][/font]``
+    Change the font (note: this refers to a TTF file or registered alias)
+``[font_context=<str>][/font_context]``
+    Change context for the font, use string value "none" for isolated context.
+``[font_family=<str>][/font_family]``
+    Font family to request for drawing. This is only valid when using a
+    font context, and takes precedence over `[font]`. See
+    :class:`kivy.uix.label.Label` for details.
+``[font_features=<str>][/font_features]``
+    OpenType font features, in CSS format, this is passed straight
+    through to Pango. The effects of requesting a feature depends on loaded
+    fonts, library versions, etc. Pango only, requires v1.38 or later.
+``[size=<size>][/size]``
+    Change the font size. <size> should be an integer, optionally with a
+    unit (i.e. ``16sp``)
+``[color=#<color>][/color]``
+    Change the text color
+``[ref=<str>][/ref]``
+    Add an interactive zone. The reference + all the word box inside the
+    reference will be available in :attr:`MarkupLabel.refs`
+``[anchor=<str>]``
+    Put an anchor in the text. You can get the position of your anchor within
+    the text with :attr:`MarkupLabel.anchors`
+``[sub][/sub]``
+    Display the text at a subscript position relative to the text before it.
+``[sup][/sup]``
+    Display the text at a superscript position relative to the text before it.
+``[text_language=<str>][/text_language]``
+    Language of the text, this is an RFC-3066 format language tag (as string),
+    for example "en_US", "zh_CN", "fr" or "ja". This can impact font selection,
+    metrics and rendering. For example, the same bytes of text can look
+    different for `ur` and `ar` languages, though both use Arabic script.
+    Use the string `'none'` to revert to locale detection. Pango only.
+
+If you need to escape the markup from the current text, use
+:func:`kivy.utils.escape_markup`.
+'''
+
+__all__ = ('MarkupLabel', )
+
+import re
+from kivy.properties import dpi2px
+from kivy.parser import parse_color
+from kivy.logger import Logger
+from kivy.core.text import Label, LabelBase
+from kivy.core.text.text_layout import layout_text, LayoutWord, LayoutLine
+from copy import copy
+from functools import partial
+
+# We need to do this trick when documentation is generated
+MarkupLabelBase = Label
+if Label is None:
+    MarkupLabelBase = LabelBase
+
+
+class MarkupLabel(MarkupLabelBase):
+    '''Markup text label.
+
+    See module documentation for more information.
+    '''
+
+    def __init__(self, *largs, **kwargs):
+        self._style_stack = {}
+        self._refs = {}
+        self._anchors = {}
+        super(MarkupLabel, self).__init__(*largs, **kwargs)
+        self._internal_size = 0, 0
+        self._cached_lines = []
+
+    @property
+    def refs(self):
+        '''Get the bounding box of all the ``[ref=...]``::
+
+            { 'refA': ((x1, y1, x2, y2), (x1, y1, x2, y2)), ... }
+        '''
+        return self._refs
+
+    @property
+    def anchors(self):
+        '''Get the position of all the ``[anchor=...]``::
+
+            { 'anchorA': (x, y), 'anchorB': (x, y), ... }
+        '''
+        return self._anchors
+
+    @property
+    def markup(self):
+        '''Return the text with all the markup split::
+
+            >>> MarkupLabel('[b]Hello world[/b]').markup
+            >>> ('[b]', 'Hello world', '[/b]')
+
+        '''
+        s = re.split(r'(\[.*?\])', self.label)
+        s = [x for x in s if x != '']
+        return s
+
+    def _push_style(self, k):
+        if k not in self._style_stack:
+            self._style_stack[k] = []
+        self._style_stack[k].append(self.options[k])
+
+    def _pop_style(self, k):
+        if k not in self._style_stack or len(self._style_stack[k]) == 0:
+            Logger.warning('Label: pop style stack without push')
+            return
+        v = self._style_stack[k].pop()
+        self.options[k] = v
+
+    def render(self, real=False):
+        options = copy(self.options)
+        if not real:
+            ret = self._pre_render()
+        else:
+            ret = self._render_real()
+        self.options = options
+        return ret
+
+    def _pre_render(self):
+        # split markup, words, and lines
+        # result: list of word with position and width/height
+        # during the first pass, we don't care about h/valign
+        self._cached_lines = lines = []
+        self._refs = {}
+        self._anchors = {}
+        clipped = False
+        w = h = 0
+        uw, uh = self.text_size
+        spush = self._push_style
+        spop = self._pop_style
+        options = self.options
+        options['_ref'] = None
+        options['_anchor'] = None
+        options['script'] = 'normal'
+        shorten = options['shorten']
+        # if shorten, then don't split lines to fit uw, because it will be
+        # flattened later when shortening and broken up lines if broken
+        # mid-word will have space mid-word when lines are joined
+        uw_temp = None if shorten else uw
+        xpad = options['padding_x']
+        uhh = (None if uh is not None and options['valign'] != 'top' or
+               options['shorten'] else uh)
+        options['strip'] = options['strip'] or options['halign'] == 'justify'
+        find_base_dir = Label.find_base_direction
+        base_dir = options['base_direction']
+        self._resolved_base_dir = None
+        for item in self.markup:
+            if item == '[b]':
+                spush('bold')
+                options['bold'] = True
+                self.resolve_font_name()
+            elif item == '[/b]':
+                spop('bold')
+                self.resolve_font_name()
+            elif item == '[i]':
+                spush('italic')
+                options['italic'] = True
+                self.resolve_font_name()
+            elif item == '[/i]':
+                spop('italic')
+                self.resolve_font_name()
+            elif item == '[u]':
+                spush('underline')
+                options['underline'] = True
+                self.resolve_font_name()
+            elif item == '[/u]':
+                spop('underline')
+                self.resolve_font_name()
+            elif item == '[s]':
+                spush('strikethrough')
+                options['strikethrough'] = True
+                self.resolve_font_name()
+            elif item == '[/s]':
+                spop('strikethrough')
+                self.resolve_font_name()
+            elif item[:6] == '[size=':
+                item = item[6:-1]
+                try:
+                    if item[-2:] in ('px', 'pt', 'in', 'cm', 'mm', 'dp', 'sp'):
+                        size = dpi2px(item[:-2], item[-2:])
+                    else:
+                        size = int(item)
+                except ValueError:
+                    raise
+                    size = options['font_size']
+                spush('font_size')
+                options['font_size'] = size
+            elif item == '[/size]':
+                spop('font_size')
+            elif item[:7] == '[color=':
+                color = parse_color(item[7:-1])
+                spush('color')
+                options['color'] = color
+            elif item == '[/color]':
+                spop('color')
+            elif item[:6] == '[font=':
+                fontname = item[6:-1]
+                spush('font_name')
+                options['font_name'] = fontname
+                self.resolve_font_name()
+            elif item == '[/font]':
+                spop('font_name')
+                self.resolve_font_name()
+            elif item[:13] == '[font_family=':
+                spush('font_family')
+                options['font_family'] = item[13:-1]
+            elif item == '[/font_family]':
+                spop('font_family')
+            elif item[:14] == '[font_context=':
+                fctx = item[14:-1]
+                if not fctx or fctx.lower() == 'none':
+                    fctx = None
+                spush('font_context')
+                options['font_context'] = fctx
+            elif item == '[/font_context]':
+                spop('font_context')
+            elif item[:15] == '[font_features=':
+                spush('font_features')
+                options['font_features'] = item[15:-1]
+            elif item == '[/font_features]':
+                spop('font_features')
+            elif item[:15] == '[text_language=':
+                lang = item[15:-1]
+                if not lang or lang.lower() == 'none':
+                    lang = None
+                spush('text_language')
+                options['text_language'] = lang
+            elif item == '[/text_language]':
+                spop('text_language')
+            elif item[:5] == '[sub]':
+                spush('font_size')
+                spush('script')
+                options['font_size'] = options['font_size'] * .5
+                options['script'] = 'subscript'
+            elif item == '[/sub]':
+                spop('font_size')
+                spop('script')
+            elif item[:5] == '[sup]':
+                spush('font_size')
+                spush('script')
+                options['font_size'] = options['font_size'] * .5
+                options['script'] = 'superscript'
+            elif item == '[/sup]':
+                spop('font_size')
+                spop('script')
+            elif item[:5] == '[ref=':
+                ref = item[5:-1]
+                spush('_ref')
+                options['_ref'] = ref
+            elif item == '[/ref]':
+                spop('_ref')
+            elif not clipped and item[:8] == '[anchor=':
+                options['_anchor'] = item[8:-1]
+            elif not clipped:
+                item = item.replace('&bl;', '[').replace(
+                    '&br;', ']').replace('&amp;', '&')
+                if not base_dir:
+                    base_dir = self._resolved_base_dir = find_base_dir(item)
+                opts = copy(options)
+                extents = self.get_cached_extents()
+                opts['space_width'] = extents(' ')[0]
+                w, h, clipped = layout_text(
+                    item, lines, (w, h), (uw_temp, uhh),
+                    opts, extents,
+                    append_down=True,
+                    complete=False
+                )
+
+        if len(lines):  # remove any trailing spaces from the last line
+            old_opts = self.options
+            self.options = copy(opts)
+            w, h, clipped = layout_text(
+                '', lines, (w, h), (uw_temp, uhh),
+                self.options, self.get_cached_extents(),
+                append_down=True,
+                complete=True
+            )
+            self.options = old_opts
+
+        self.is_shortened = False
+        if shorten:
+            options['_ref'] = None  # no refs for you!
+            options['_anchor'] = None
+            w, h, lines = self.shorten_post(lines, w, h)
+            self._cached_lines = lines
+        # when valign is not top, for markup we layout everything (text_size[1]
+        # is temporarily set to None) and after layout cut to size if too tall
+        elif uh != uhh and h > uh and len(lines) > 1:
+            if options['valign'] == 'bottom':
+                i = 0
+                while i < len(lines) - 1 and h > uh:
+                    h -= lines[i].h
+                    i += 1
+                del lines[:i]
+            else:  # middle
+                i = 0
+                top = int(h / 2. + uh / 2.)  # remove extra top portion
+                while i < len(lines) - 1 and h > top:
+                    h -= lines[i].h
+                    i += 1
+                del lines[:i]
+                i = len(lines) - 1  # remove remaining bottom portion
+                while i and h > uh:
+                    h -= lines[i].h
+                    i -= 1
+                del lines[i + 1:]
+
+        # now justify the text
+        if options['halign'] == 'justify' and uw is not None:
+            # XXX: update refs to justified pos
+            # when justify, each line should've been stripped already
+            split = partial(re.split, re.compile('( +)'))
+            uww = uw - 2 * xpad
+            chr = type(self.text)
+            space = chr(' ')
+            empty = chr('')
+
+            for i in range(len(lines)):
+                line = lines[i]
+                words = line.words
+                # if there's nothing to justify, we're done
+                if (not line.w or int(uww - line.w) <= 0 or not len(words) or
+                        line.is_last_line):
+                    continue
+
+                done = False
+                parts = [None, ] * len(words)  # contains words split by space
+                idxs = [None, ] * len(words)  # indices of the space in parts
+                # break each word into spaces and add spaces until it's full
+                # do first round of split in case we don't need to split all
+                for w in range(len(words)):
+                    word = words[w]
+                    sw = word.options['space_width']
+                    p = parts[w] = split(word.text)
+                    idxs[w] = [v for v in range(len(p)) if
+                               p[v].startswith(' ')]
+                    # now we have the indices of the spaces in split list
+                    for k in idxs[w]:
+                        # try to add single space at each space
+                        if line.w + sw > uww:
+                            done = True
+                            break
+                        line.w += sw
+                        word.lw += sw
+                        p[k] += space
+                    if done:
+                        break
+
+                # there's not a single space in the line?
+                if not any(idxs):
+                    continue
+
+                # now keep adding spaces to already split words until done
+                while not done:
+                    for w in range(len(words)):
+                        if not idxs[w]:
+                            continue
+                        word = words[w]
+                        sw = word.options['space_width']
+                        p = parts[w]
+                        for k in idxs[w]:
+                            # try to add single space at each space
+                            if line.w + sw > uww:
+                                done = True
+                                break
+                            line.w += sw
+                            word.lw += sw
+                            p[k] += space
+                        if done:
+                            break
+
+                # if not completely full, push last words to right edge
+                diff = int(uww - line.w)
+                if diff > 0:
+                    # find the last word that had a space
+                    for w in range(len(words) - 1, -1, -1):
+                        if not idxs[w]:
+                            continue
+                        break
+                    old_opts = self.options
+                    self.options = word.options
+                    word = words[w]
+                    # split that word into left/right and push right till uww
+                    l_text = empty.join(parts[w][:idxs[w][-1]])
+                    r_text = empty.join(parts[w][idxs[w][-1]:])
+                    left = LayoutWord(
+                        word.options,
+                        self.get_extents(l_text)[0],
+                        word.lh,
+                        l_text
+                    )
+                    right = LayoutWord(
+                        word.options,
+                        self.get_extents(r_text)[0],
+                        word.lh,
+                        r_text
+                    )
+                    left.lw = max(left.lw, word.lw + diff - right.lw)
+                    self.options = old_opts
+
+                    # now put words back together with right/left inserted
+                    for k in range(len(words)):
+                        if idxs[k]:
+                            words[k].text = empty.join(parts[k])
+                    words[w] = right
+                    words.insert(w, left)
+                else:
+                    for k in range(len(words)):
+                        if idxs[k]:
+                            words[k].text = empty.join(parts[k])
+                line.w = uww
+                w = max(w, uww)
+
+        self._internal_size = w, h
+        if uw:
+            w = uw
+        if uh:
+            h = uh
+        if h > 1 and w < 2:
+            w = 2
+        if w < 1:
+            w = 1
+        if h < 1:
+            h = 1
+        return int(w), int(h)
+
+    def render_lines(self, lines, options, render_text, y, size):
+        xpad = options['padding_x']
+        w = size[0]
+        halign = options['halign']
+        refs = self._refs
+        anchors = self._anchors
+        base_dir = options['base_direction'] or self._resolved_base_dir
+        auto_halign_r = halign == 'auto' and base_dir and 'rtl' in base_dir
+
+        for layout_line in lines:  # for plain label each line has only one str
+            lw, lh = layout_line.w, layout_line.h
+            x = xpad
+            if halign == 'center':
+                x = int((w - lw) / 2.)
+            elif halign == 'right' or auto_halign_r:
+                x = max(0, int(w - lw - xpad))
+            layout_line.x = x
+            layout_line.y = y
+            psp = pph = 0
+            for word in layout_line.words:
+                options = self.options = word.options
+                # the word height is not scaled by line_height, only lh was
+                wh = options['line_height'] * word.lh
+                # calculate sub/super script pos
+                if options['script'] == 'superscript':
+                    script_pos = max(0, psp if psp else self.get_descent())
+                    psp = script_pos
+                    pph = wh
+                elif options['script'] == 'subscript':
+                    script_pos = min(lh - wh, ((psp + pph) - wh)
+                                     if pph else (lh - wh))
+                    pph = wh
+                    psp = script_pos
+                else:
+                    script_pos = (lh - wh) / 1.25
+                    psp = pph = 0
+                if len(word.text):
+                    render_text(word.text, x, y + script_pos)
+
+                # should we record refs ?
+                ref = options['_ref']
+                if ref is not None:
+                    if ref not in refs:
+                        refs[ref] = []
+                    refs[ref].append((x, y, x + word.lw, y + wh))
+
+                # Should we record anchors?
+                anchor = options['_anchor']
+                if anchor is not None:
+                    if anchor not in anchors:
+                        anchors[anchor] = (x, y)
+                x += word.lw
+            y += lh
+        return y
+
+    def shorten_post(self, lines, w, h, margin=2):
+        ''' Shortens the text to a single line according to the label options.
+
+        This function operates on a text that has already been laid out because
+        for markup, parts of text can have different size and options.
+
+        If :attr:`text_size` [0] is None, the lines are returned unchanged.
+        Otherwise, the lines are converted to a single line fitting within the
+        constrained width, :attr:`text_size` [0].
+
+        :params:
+
+            `lines`: list of `LayoutLine` instances describing the text.
+            `w`: int, the width of the text in lines, including padding.
+            `h`: int, the height of the text in lines, including padding.
+            `margin` int, the additional space left on the sides. This is in
+            addition to :attr:`padding_x`.
+
+        :returns:
+            3-tuple of (xw, h, lines), where w, and h is similar to the input
+            and contains the resulting width / height of the text, including
+            padding. lines, is a list containing a single `LayoutLine`, which
+            contains the words for the line.
+        '''
+
+        def n(line, c):
+            ''' A function similar to text.find, except it's an iterator that
+            returns successive occurrences of string c in list line. line is
+            not a string, but a list of LayoutWord instances that we walk
+            from left to right returning the indices of c in the words as we
+            encounter them. Note that the options can be different among the
+            words.
+
+            :returns:
+                3-tuple: the index of the word in line, the index of the
+                occurrence in word, and the extents (width) of the combined
+                words until this occurrence, not including the occurrence char.
+                If no more are found it returns (-1, -1, total_w) where total_w
+                is the full width of all the words.
+            '''
+            total_w = 0
+            for w in range(len(line)):
+                word = line[w]
+                if not word.lw:
+                    continue
+                f = partial(word.text.find, c)
+                i = f()
+                while i != -1:
+                    self.options = word.options
+                    yield w, i, total_w + self.get_extents(word.text[:i])[0]
+                    i = f(i + 1)
+                self.options = word.options
+                total_w += self.get_extents(word.text)[0]
+            yield -1, -1, total_w  # this should never be reached, really
+
+        def p(line, c):
+            ''' Similar to the `n` function, except it returns occurrences of c
+            from right to left in the list, line, similar to rfind.
+            '''
+            total_w = 0
+            offset = 0 if len(c) else 1
+            for w in range(len(line) - 1, -1, -1):
+                word = line[w]
+                if not word.lw:
+                    continue
+                f = partial(word.text.rfind, c)
+                i = f()
+                while i != -1:
+                    self.options = word.options
+                    yield (w, i, total_w +
+                           self.get_extents(word.text[i + 1:])[0])
+                    if i:
+                        i = f(0, i - offset)
+                    else:
+                        if not c:
+                            self.options = word.options
+                            yield (w, -1, total_w +
+                                   self.get_extents(word.text)[0])
+                        break
+                self.options = word.options
+                total_w += self.get_extents(word.text)[0]
+            yield -1, -1, total_w  # this should never be reached, really
+
+        def n_restricted(line, uw, c):
+            ''' Similar to the function `n`, except it only returns the first
+            occurrence and it's not an iterator. Furthermore, if the first
+            occurrence doesn't fit within width uw, it returns the index of
+            whatever amount of text will still fit in uw.
+
+            :returns:
+                similar to the function `n`, except it's a 4-tuple, with the
+                last element a boolean, indicating if we had to clip the text
+                to fit in uw (True) or if the whole text until the first
+                occurrence fitted in uw (False).
+            '''
+            total_w = 0
+            if not len(line):
+                return 0, 0, 0
+            for w in range(len(line)):
+                word = line[w]
+                f = partial(word.text.find, c)
+                self.options = word.options
+                extents = self.get_cached_extents()
+                i = f()
+                if i != -1:
+                    ww = extents(word.text[:i])[0]
+
+                if i != -1 and total_w + ww <= uw:  # found and it fits
+                    return w, i, total_w + ww, False
+                elif i == -1:
+                    ww = extents(word.text)[0]
+                    if total_w + ww <= uw:  # wasn't found and all fits
+                        total_w += ww
+                        continue
+                    i = len(word.text)
+
+                # now just find whatever amount of the word does fit
+                e = 0
+                while e != i and total_w + extents(word.text[:e])[0] <= uw:
+                    e += 1
+                e = max(0, e - 1)
+                return w, e, total_w + extents(word.text[:e])[0], True
+
+            return -1, -1, total_w, False
+
+        def p_restricted(line, uw, c):
+            ''' Similar to `n_restricted`, except it returns the first
+            occurrence starting from the right, like `p`.
+            '''
+            total_w = 0
+            if not len(line):
+                return 0, 0, 0
+            for w in range(len(line) - 1, -1, -1):
+                word = line[w]
+                f = partial(word.text.rfind, c)
+                self.options = word.options
+                extents = self.get_cached_extents()
+                i = f()
+                if i != -1:
+                    ww = extents(word.text[i + 1:])[0]
+
+                if i != -1 and total_w + ww <= uw:  # found and it fits
+                    return w, i, total_w + ww, False
+                elif i == -1:
+                    ww = extents(word.text)[0]
+                    if total_w + ww <= uw:  # wasn't found and all fits
+                        total_w += ww
+                        continue
+
+                # now just find whatever amount of the word does fit
+                s = len(word.text) - 1
+                while s >= 0 and total_w + extents(word.text[s:])[0] <= uw:
+                    s -= 1
+                return w, s, total_w + extents(word.text[s + 1:])[0], True
+
+            return -1, -1, total_w, False
+
+        textwidth = self.get_cached_extents()
+        uw = self.text_size[0]
+        if uw is None:
+            return w, h, lines
+        old_opts = copy(self.options)
+        uw = max(0, int(uw - old_opts['padding_x'] * 2 - margin))
+        chr = type(self.text)
+        ssize = textwidth(' ')
+        c = old_opts['split_str']
+        line_height = old_opts['line_height']
+        xpad, ypad = old_opts['padding_x'], old_opts['padding_y']
+        dir = old_opts['shorten_from'][0]
+
+        # flatten lines into single line
+        line = []
+        last_w = 0
+        for l in range(len(lines)):
+            # concatenate (non-empty) inside lines with a space
+            this_line = lines[l]
+            if last_w and this_line.w and not this_line.line_wrap:
+                line.append(LayoutWord(old_opts, ssize[0], ssize[1], chr(' ')))
+            last_w = this_line.w or last_w
+            for word in this_line.words:
+                if word.lw:
+                    line.append(word)
+
+        # if that fits, just return the flattened line
+        lw = sum([word.lw for word in line])
+        if lw <= uw:
+            lh = max([word.lh for word in line] + [0]) * line_height
+            self.is_shortened = False
+            return (
+                lw + 2 * xpad,
+                lh + 2 * ypad,
+                [LayoutLine(0, 0, lw, lh, 1, 0, line)]
+            )
+
+        elps_opts = copy(old_opts)
+        if 'ellipsis_options' in old_opts:
+            elps_opts.update(old_opts['ellipsis_options'])
+
+        # Set new opts for ellipsis
+        self.options = elps_opts
+        # find the size of ellipsis that'll fit
+        elps_s = textwidth('...')
+        if elps_s[0] > uw:  # even ellipsis didn't fit...
+            self.is_shortened = True
+            s = textwidth('..')
+            if s[0] <= uw:
+                return (
+                    s[0] + 2 * xpad,
+                    s[1] * line_height + 2 * ypad,
+                    [LayoutLine(
+                        0, 0, s[0], s[1], 1, 0,
+                        [LayoutWord(old_opts, s[0], s[1], '..')])]
+                )
+
+            else:
+                s = textwidth('.')
+                return (
+                    s[0] + 2 * xpad,
+                    s[1] * line_height + 2 * ypad,
+                    [LayoutLine(
+                        0, 0, s[0], s[1], 1, 0,
+                        [LayoutWord(old_opts, s[0], s[1], '.')])]
+                )
+
+        elps = LayoutWord(elps_opts, elps_s[0], elps_s[1], '...')
+        uw -= elps_s[0]
+        # Restore old opts
+        self.options = old_opts
+
+        # now find the first left and right words that fit
+        w1, e1, l1, clipped1 = n_restricted(line, uw, c)
+        w2, s2, l2, clipped2 = p_restricted(line, uw, c)
+
+        if dir != 'l':  # center or right
+            line1 = None
+            if clipped1 or clipped2 or l1 + l2 > uw:
+                # if either was clipped or both don't fit, just take first
+                if len(c):
+                    self.options = old_opts
+                    old_opts['split_str'] = ''
+                    res = self.shorten_post(lines, w, h, margin)
+                    self.options['split_str'] = c
+                    self.is_shortened = True
+                    return res
+                line1 = line[:w1]
+                last_word = line[w1]
+                last_text = last_word.text[:e1]
+                self.options = last_word.options
+                s = self.get_extents(last_text)
+                line1.append(LayoutWord(last_word.options, s[0], s[1],
+                                        last_text))
+            elif (w1, e1) == (-1, -1):  # this shouldn't occur
+                line1 = line
+            if line1:
+                line1.append(elps)
+                lw = sum([word.lw for word in line1])
+                lh = max([word.lh for word in line1]) * line_height
+                self.options = old_opts
+                self.is_shortened = True
+                return (
+                    lw + 2 * xpad,
+                    lh + 2 * ypad,
+                    [LayoutLine(0, 0, lw, lh, 1, 0, line1)]
+                )
+
+            # now we know that both the first and last word fit, and that
+            # there's at least one instances of the split_str in the line
+            if (w1, e1) != (w2, s2):  # more than one split_str
+                if dir == 'r':
+                    f = n(line, c)  # iterator
+                    assert next(f)[:-1] == (w1, e1)  # first word should match
+                    ww1, ee1, l1 = next(f)
+                    while l2 + l1 <= uw:
+                        w1, e1 = ww1, ee1
+                        ww1, ee1, l1 = next(f)
+                        if (w1, e1) == (w2, s2):
+                            break
+                else:   # center
+                    f = n(line, c)  # iterator
+                    f_inv = p(line, c)  # iterator
+                    assert next(f)[:-1] == (w1, e1)
+                    assert next(f_inv)[:-1] == (w2, s2)
+                    while True:
+                        if l1 <= l2:
+                            ww1, ee1, l1 = next(f)  # hypothesize that next fit
+                            if l2 + l1 > uw:
+                                break
+                            w1, e1 = ww1, ee1
+                            if (w1, e1) == (w2, s2):
+                                break
+                        else:
+                            ww2, ss2, l2 = next(f_inv)
+                            if l2 + l1 > uw:
+                                break
+                            w2, s2 = ww2, ss2
+                            if (w1, e1) == (w2, s2):
+                                break
+        else:  # left
+            line1 = [elps]
+            if clipped1 or clipped2 or l1 + l2 > uw:
+                # if either was clipped or both don't fit, just take last
+                if len(c):
+                    self.options = old_opts
+                    old_opts['split_str'] = ''
+                    res = self.shorten_post(lines, w, h, margin)
+                    self.options['split_str'] = c
+                    self.is_shortened = True
+                    return res
+                first_word = line[w2]
+                first_text = first_word.text[s2 + 1:]
+                self.options = first_word.options
+                s = self.get_extents(first_text)
+                line1.append(LayoutWord(first_word.options, s[0], s[1],
+                                        first_text))
+                line1.extend(line[w2 + 1:])
+            elif (w1, e1) == (-1, -1):  # this shouldn't occur
+                line1 = line
+            if len(line1) != 1:
+                lw = sum([word.lw for word in line1])
+                lh = max([word.lh for word in line1]) * line_height
+                self.options = old_opts
+                self.is_shortened = True
+                return (
+                    lw + 2 * xpad,
+                    lh + 2 * ypad,
+                    [LayoutLine(0, 0, lw, lh, 1, 0, line1)]
+                )
+
+            # now we know that both the first and last word fit, and that
+            # there's at least one instances of the split_str in the line
+            if (w1, e1) != (w2, s2):  # more than one split_str
+                f_inv = p(line, c)  # iterator
+                assert next(f_inv)[:-1] == (w2, s2)  # last word should match
+                ww2, ss2, l2 = next(f_inv)
+                while l2 + l1 <= uw:
+                    w2, s2 = ww2, ss2
+                    ww2, ss2, l2 = next(f_inv)
+                    if (w1, e1) == (w2, s2):
+                        break
+
+        # now add back the left half
+        line1 = line[:w1]
+        last_word = line[w1]
+        last_text = last_word.text[:e1]
+        self.options = last_word.options
+        s = self.get_extents(last_text)
+        if len(last_text):
+            line1.append(LayoutWord(last_word.options, s[0], s[1], last_text))
+        line1.append(elps)
+
+        # now add back the right half
+        first_word = line[w2]
+        first_text = first_word.text[s2 + 1:]
+        self.options = first_word.options
+        s = self.get_extents(first_text)
+        if len(first_text):
+            line1.append(LayoutWord(first_word.options, s[0], s[1],
+                                    first_text))
+        line1.extend(line[w2 + 1:])
+
+        lw = sum([word.lw for word in line1])
+        lh = max([word.lh for word in line1]) * line_height
+        self.options = old_opts
+        if uw < lw:
+            self.is_shortened = True
+        return (
+            lw + 2 * xpad,
+            lh + 2 * ypad,
+            [LayoutLine(0, 0, lw, lh, 1, 0, line1)]
+        )
diff --git a/kivy/core/text/text_layout.cpython-310-x86_64-linux-gnu.so b/kivy/core/text/text_layout.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..24dafab
Binary files /dev/null and b/kivy/core/text/text_layout.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/core/text/text_layout.pxd b/kivy/core/text/text_layout.pxd
new file mode 100644
index 0000000..bb6e397
--- /dev/null
+++ b/kivy/core/text/text_layout.pxd
@@ -0,0 +1,13 @@
+
+
+cdef class LayoutWord:
+    cdef public object text
+    cdef public int lw, lh
+    cdef public dict options
+
+
+cdef class LayoutLine:
+    cdef public int x, y, w, h
+    cdef public int line_wrap  # whether this line wraps from last line
+    cdef public int is_last_line  # in a paragraph
+    cdef public list words
diff --git a/kivy/core/text/text_pango.py b/kivy/core/text/text_pango.py
new file mode 100644
index 0000000..615053c
--- /dev/null
+++ b/kivy/core/text/text_pango.py
@@ -0,0 +1,145 @@
+'''
+Pango text provider
+===================
+
+.. versionadded:: 1.11.0
+
+.. warning::
+    The low-level Pango API is experimental, and subject to change without
+    notice for as long as this warning is present.
+
+
+Installation
+------------
+
+1. Install pangoft2 (`apt install libfreetype6-dev libpango1.0-dev
+   libpangoft2-1.0-0`) or ensure it is available in pkg-config
+2. Recompile kivy. Check that pangoft2 is found `use_pangoft2 = 1`
+3. Test it! Enforce the text core renderer to pango using environment variable:
+   `export KIVY_TEXT=pango`
+
+This has been tested on OSX and Linux, Python 3.6.
+
+
+Font context types for FontConfig+FreeType2 backend
+---------------------------------------------------
+
+* `system://` - `FcInitLoadConfigAndFonts()`
+* `systemconfig://` - `FcInitLoadConfig()`
+* `directory://<PATH>` - `FcInitLoadConfig()` + `FcAppFontAddDir()`
+* `fontconfig://<PATH>` - `FcConfigCreate()` + `FcConfigParseAndLoad()`
+* Any other context name - `FcConfigCreate()`
+
+
+Low-level Pango access
+----------------------
+
+Since Kivy currently does its own text layout, the Label and TextInput widgets
+do not take full advantage of Pango. For example, line breaks do not take
+language/script into account, and switching alignment per paragraph (for bi-
+directional text) is not supported. For advanced i18n requirements, we provide
+a simple wrapper around PangoLayout that you can use to render text.
+
+* https://developer.gnome.org/pango/1.40/pango-Layout-Objects.html
+* https://developer.gnome.org/pango/1.40/PangoMarkupFormat.html
+* See the `kivy/core/text/_text_pango.pyx` file @ `cdef class KivyPangoLayout`
+  for more information. Not all features of PangoLayout are implemented.
+
+.. python::
+    from kivy.core.window import Window  # OpenGL must be initialized
+    from kivy.core.text._text_pango import KivyPangoLayout
+    layout = KivyPangoLayout('system://')
+    layout.set_markup('<span font="20">Hello <b>World!</b></span>')
+    tex = layout.render_as_Texture()
+
+
+Known limitations
+-----------------
+
+* Pango versions older than v1.38 has not been tested. It may work on
+  some systems with older pango and newer FontConfig/FreeType2 versions.
+* Kivy's text layout is used, not Pango. This means we do not use Pango's
+  line-breaking feature (which is superior to Kivy's), and we can't use
+  Pango's bidirectional cursor helpers in TextInput.
+* Font family collissions can happen. For example, if you use a `system://`
+  context and add a custom `Arial.ttf`, using `arial` as the `font_family`
+  may or may not draw with your custom font (depending on whether or not
+  there is already a system-wide "arial" font installed)
+* Rendering is inefficient; the normal way to integrate Pango would be
+  using a dedicated PangoLayout per widget. This is not currently practical
+  due to missing abstractions in Kivy core (in the current implementation,
+  we have a dedicated PangoLayout *per font context,* which is rendered
+  once for each LayoutWord)
+'''
+
+__all__ = ('LabelPango', )
+
+from types import MethodType
+from os.path import isfile
+from kivy.resources import resource_find
+from kivy.core.text import LabelBase, FontContextManagerBase
+from kivy.core.text._text_pango import (
+        KivyPangoRenderer,
+        kpango_get_extents,
+        kpango_get_ascent,
+        kpango_get_descent,
+        kpango_find_base_dir,
+        kpango_font_context_exists,
+        kpango_font_context_create,
+        kpango_font_context_destroy,
+        kpango_font_context_add_font,
+        kpango_font_context_list,
+        kpango_font_context_list_custom,
+        kpango_font_context_list_families)
+
+
+class LabelPango(LabelBase):
+
+    _font_family_support = True
+
+    def __init__(self, *largs, **kwargs):
+        self.get_extents = MethodType(kpango_get_extents, self)
+        self.get_ascent = MethodType(kpango_get_ascent, self)
+        self.get_descent = MethodType(kpango_get_descent, self)
+        super(LabelPango, self).__init__(*largs, **kwargs)
+
+    find_base_direction = staticmethod(kpango_find_base_dir)
+
+    def _render_begin(self):
+        self._rdr = KivyPangoRenderer(*self._size)
+
+    def _render_text(self, text, x, y):
+        self._rdr.render(self, text, x, y)
+
+    def _render_end(self):
+        imgdata = self._rdr.get_ImageData()
+        del self._rdr
+        return imgdata
+
+
+class PangoFontContextManager(FontContextManagerBase):
+    create = staticmethod(kpango_font_context_create)
+    exists = staticmethod(kpango_font_context_exists)
+    destroy = staticmethod(kpango_font_context_destroy)
+    list = staticmethod(kpango_font_context_list)
+    list_families = staticmethod(kpango_font_context_list_families)
+    list_custom = staticmethod(kpango_font_context_list_custom)
+
+    @staticmethod
+    def add_font(font_context, filename, autocreate=True, family=None):
+        if not autocreate and not PangoFontContextManager.exists(font_context):
+            raise Exception("FontContextManager: Attempt to add font file "
+                            "'{}' to non-existing context '{}' without "
+                            "autocreate.".format(filename, font_context))
+        if not filename:
+            raise Exception("FontContextManager: Cannot add empty font file")
+        if not isfile(filename):
+            filename = resource_find(filename)
+        if not isfile(filename):
+            if not filename.endswith('.ttf'):
+                filename = resource_find('{}.ttf'.format(filename))
+        if filename and isfile(filename):
+            return kpango_font_context_add_font(font_context, filename)
+        raise Exception("FontContextManager: Attempt to add non-existent "
+                        "font file: '{}' to context '{}'"
+                        .format(filename, font_context))
diff --git a/kivy/core/text/text_pil.py b/kivy/core/text/text_pil.py
new file mode 100644
index 0000000..6549166
--- /dev/null
+++ b/kivy/core/text/text_pil.py
@@ -0,0 +1,60 @@
+'''
+Text PIL: Draw text with PIL
+'''
+
+__all__ = ('LabelPIL', )
+
+from PIL import Image, ImageFont, ImageDraw
+
+
+from kivy.compat import text_type
+from kivy.core.text import LabelBase
+from kivy.core.image import ImageData
+
+# used for fetching extends before creature image surface
+default_font = ImageFont.load_default()
+
+
+class LabelPIL(LabelBase):
+    _cache = {}
+
+    def _select_font(self):
+        fontsize = int(self.options['font_size'])
+        fontname = self.options['font_name_r']
+        try:
+            id = '%s.%s' % (text_type(fontname), text_type(fontsize))
+        except UnicodeDecodeError:
+            id = '%s.%s' % (fontname, fontsize)
+
+        if id not in self._cache:
+            font = ImageFont.truetype(fontname, fontsize)
+            self._cache[id] = font
+
+        return self._cache[id]
+
+    def get_extents(self, text):
+        font = self._select_font()
+        w, h = font.getsize(text)
+        return w, h
+
+    def get_cached_extents(self):
+        return self._select_font().getsize
+
+    def _render_begin(self):
+        # create a surface, context, font...
+        self._pil_im = Image.new('RGBA', self._size, color=(255, 255, 255, 0))
+        self._pil_draw = ImageDraw.Draw(self._pil_im)
+
+    def _render_text(self, text, x, y):
+        color = tuple([int(c * 255) for c in self.options['color']])
+        self._pil_draw.text((int(x), int(y)),
+                            text, font=self._select_font(), fill=color)
+
+    def _render_end(self):
+        data = ImageData(self._size[0], self._size[1],
+                         self._pil_im.mode.lower(), self._pil_im.tobytes())
+
+        del self._pil_im
+        del self._pil_draw
+
+        return data
diff --git a/kivy/core/text/text_pygame.py b/kivy/core/text/text_pygame.py
new file mode 100644
index 0000000..21cac7a
--- /dev/null
+++ b/kivy/core/text/text_pygame.py
@@ -0,0 +1,117 @@
+'''
+Text Pygame: Draw text with pygame
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('LabelPygame', )
+
+from kivy.compat import PY2
+from kivy.core.text import LabelBase
+from kivy.core.image import ImageData
+from kivy.utils import deprecated
+
+try:
+    import pygame
+except:
+    raise
+
+pygame_cache = {}
+pygame_font_handles = {}
+pygame_cache_order = []
+
+# init pygame font
+try:
+    pygame.ftfont.init()
+except:
+    pygame.font.init()
+
+
+class LabelPygame(LabelBase):
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, *largs, **kwargs):
+        super(LabelPygame, self).__init__(*largs, **kwargs)
+
+    def _get_font_id(self):
+        return '|'.join([str(self.options[x]) for x in
+                         ('font_size', 'font_name_r', 'bold', 'italic')])
+
+    def _get_font(self):
+        fontid = self._get_font_id()
+        if fontid not in pygame_cache:
+            # try first the file if it's a filename
+            font_handle = fontobject = None
+            fontname = self.options['font_name_r']
+            ext = fontname.rsplit('.', 1)
+            if len(ext) == 2:
+                # try to open the font if it has an extension
+                font_handle = open(fontname, 'rb')
+                fontobject = pygame.font.Font(font_handle,
+                                              int(self.options['font_size']))
+
+            # fallback to search a system font
+            if fontobject is None:
+                # try to search the font
+                font = pygame.font.match_font(
+                    self.options['font_name_r'].replace(' ', ''),
+                    bold=self.options['bold'],
+                    italic=self.options['italic'])
+
+                # fontobject
+                fontobject = pygame.font.Font(font,
+                                              int(self.options['font_size']))
+            pygame_cache[fontid] = fontobject
+            pygame_font_handles[fontid] = font_handle
+            pygame_cache_order.append(fontid)
+
+        # to prevent too much file open, limit the number of opened fonts to 64
+        while len(pygame_cache_order) > 64:
+            popid = pygame_cache_order.pop(0)
+            del pygame_cache[popid]
+            font_handle = pygame_font_handles.pop(popid)
+            if font_handle is not None:
+                font_handle.close()
+
+        return pygame_cache[fontid]
+
+    def get_ascent(self):
+        return self._get_font().get_ascent()
+
+    def get_descent(self):
+        return self._get_font().get_descent()
+
+    def get_extents(self, text):
+        return self._get_font().size(text)
+
+    def get_cached_extents(self):
+        return self._get_font().size
+
+    def _render_begin(self):
+        self._pygame_surface = pygame.Surface(self._size, pygame.SRCALPHA, 32)
+        self._pygame_surface.fill((0, 0, 0, 0))
+
+    def _render_text(self, text, x, y):
+        font = self._get_font()
+        color = [c * 255 for c in self.options['color']]
+        color[0], color[2] = color[2], color[0]
+        try:
+            text = font.render(text, True, color)
+            text.set_colorkey(color)
+            self._pygame_surface.blit(text, (x, y), None,
+                                      pygame.BLEND_RGBA_ADD)
+        except pygame.error:
+            pass
+
+    def _render_end(self):
+        w, h = self._size
+        data = ImageData(w, h,
+                         'rgba', self._pygame_surface.get_buffer().raw)
+
+        del self._pygame_surface
+
+        return data
diff --git a/kivy/core/text/text_sdl2.py b/kivy/core/text/text_sdl2.py
new file mode 100644
index 0000000..f72defc
--- /dev/null
+++ b/kivy/core/text/text_sdl2.py
@@ -0,0 +1,50 @@
+'''
+SDL2 text provider
+==================
+
+Based on SDL2 + SDL2_ttf
+'''
+
+__all__ = ('LabelSDL2', )
+
+from kivy.compat import PY2
+from kivy.core.text import LabelBase
+try:
+    from kivy.core.text._text_sdl2 import (_SurfaceContainer, _get_extents,
+                                           _get_fontdescent, _get_fontascent)
+except ImportError:
+    from kivy.core import handle_win_lib_import_error
+    handle_win_lib_import_error(
+        'text', 'sdl2', 'kivy.core.text._text_sdl2')
+    raise
+
+
+class LabelSDL2(LabelBase):
+
+    def _get_font_id(self):
+        return '|'.join([str(self.options[x]) for x
+            in ('font_size', 'font_name_r', 'bold',
+                'italic', 'underline', 'strikethrough')])
+
+    def get_extents(self, text):
+        try:
+            if PY2:
+                text = text.encode('UTF-8')
+        except:
+            pass
+        return _get_extents(self, text)
+
+    def get_descent(self):
+        return _get_fontdescent(self)
+
+    def get_ascent(self):
+        return _get_fontascent(self)
+
+    def _render_begin(self):
+        self._surface = _SurfaceContainer(self._size[0], self._size[1])
+
+    def _render_text(self, text, x, y):
+        self._surface.render(self, text, x, y)
+
+    def _render_end(self):
+        return self._surface.get_data()
diff --git a/kivy/core/video/__init__.py b/kivy/core/video/__init__.py
new file mode 100644
index 0000000..55392ff
--- /dev/null
+++ b/kivy/core/video/__init__.py
@@ -0,0 +1,219 @@
+'''
+Video
+=====
+
+Core class for reading video files and managing the video
+:class:`~kivy.graphics.texture.Texture`.
+
+.. versionchanged:: 1.10.0
+    The pyglet, pygst and gi providers have been removed.
+
+.. versionchanged:: 1.8.0
+    There are now 2 distinct Gstreamer implementations: one using Gi/Gst
+    working for both Python 2+3 with Gstreamer 1.0, and one using PyGST
+    working only for Python 2 + Gstreamer 0.10.
+
+.. note::
+
+    Recording is not supported.
+'''
+
+__all__ = ('VideoBase', 'Video')
+
+from kivy.clock import Clock
+from kivy.core import core_select_lib
+from kivy.event import EventDispatcher
+from kivy.logger import Logger
+from kivy.compat import PY2
+
+
+class VideoBase(EventDispatcher):
+    '''VideoBase, a class used to implement a video reader.
+
+    :Parameters:
+        `filename`: str
+            Filename of the video. Can be a file or an URI.
+        `eos`: str, defaults to 'pause'
+            Action to take when EOS is hit. Can be one of 'pause', 'stop' or
+            'loop'.
+
+            .. versionchanged:: 1.4.0
+                added 'pause'
+
+        `async`: bool, defaults to True
+            Load the video asynchronously (may be not supported by all
+            providers).
+        `autoplay`: bool, defaults to False
+            Auto play the video on init.
+
+    :Events:
+        `on_eos`
+            Fired when EOS is hit.
+        `on_load`
+            Fired when the video is loaded and the texture is available.
+        `on_frame`
+            Fired when a new frame is written to the texture.
+    '''
+
+    __slots__ = ('_wantplay', '_buffer', '_filename', '_texture',
+                 '_volume', 'eos', '_state', '_async', '_autoplay')
+
+    __events__ = ('on_eos', 'on_load', 'on_frame')
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault('filename', None)
+        kwargs.setdefault('eos', 'stop')
+        kwargs.setdefault('async', True)
+        kwargs.setdefault('autoplay', False)
+
+        super(VideoBase, self).__init__()
+
+        self._wantplay = False
+        self._buffer = None
+        self._filename = None
+        self._texture = None
+        self._volume = 1.
+        self._state = ''
+
+        self._autoplay = kwargs.get('autoplay')
+        self._async = kwargs.get('async')
+        self.eos = kwargs.get('eos')
+        if self.eos == 'pause':
+            Logger.warning("'pause' is deprecated. Use 'stop' instead.")
+            self.eos = 'stop'
+        self.filename = kwargs.get('filename')
+
+        Clock.schedule_interval(self._update, 1 / 30.)
+
+        if self._autoplay:
+            self.play()
+
+    def __del__(self):
+        self.unload()
+
+    def on_eos(self):
+        pass
+
+    def on_load(self):
+        pass
+
+    def on_frame(self):
+        pass
+
+    def _get_filename(self):
+        return self._filename
+
+    def _set_filename(self, filename):
+        if filename == self._filename:
+            return
+        self.unload()
+        self._filename = filename
+        if self._filename is None:
+            return
+        self.load()
+
+    filename = property(lambda self: self._get_filename(),
+                        lambda self, x: self._set_filename(x),
+                        doc='Get/set the filename/uri of the current video')
+
+    def _get_position(self):
+        return 0
+
+    def _set_position(self, pos):
+        self.seek(pos)
+
+    position = property(lambda self: self._get_position(),
+                        lambda self, x: self._set_position(x),
+                        doc='Get/set the position in the video (in seconds)')
+
+    def _get_volume(self):
+        return self._volume
+
+    def _set_volume(self, volume):
+        self._volume = volume
+
+    volume = property(lambda self: self._get_volume(),
+                      lambda self, x: self._set_volume(x),
+                      doc='Get/set the volume in the video (1.0 = 100%)')
+
+    def _get_duration(self):
+        return 0
+
+    duration = property(lambda self: self._get_duration(),
+                        doc='Get the video duration (in seconds)')
+
+    def _get_texture(self):
+        return self._texture
+
+    texture = property(lambda self: self._get_texture(),
+                       doc='Get the video texture')
+
+    def _get_state(self):
+        return self._state
+
+    state = property(lambda self: self._get_state(),
+                     doc='Get the video playing status')
+
+    def _do_eos(self, *args):
+        '''
+        .. versionchanged:: 1.4.0
+            Now dispatches the `on_eos` event.
+        '''
+        if self.eos == 'pause':
+            self.pause()
+        elif self.eos == 'stop':
+            self.stop()
+        elif self.eos == 'loop':
+            self.position = 0
+            self.play()
+
+        self.dispatch('on_eos')
+
+    def _update(self, dt):
+        '''Update the video content to texture.
+        '''
+        pass
+
+    def seek(self, percent, precise=True):
+        '''Move to position as percentage (strictly, a proportion from
+            0 - 1) of the duration'''
+        pass
+
+    def stop(self):
+        '''Stop the video playing'''
+        self._state = ''
+
+    def pause(self):
+        '''Pause the video
+
+        .. versionadded:: 1.4.0
+        '''
+        self._state = 'paused'
+
+    def play(self):
+        '''Play the video'''
+        self._state = 'playing'
+
+    def load(self):
+        '''Load the video from the current filename'''
+        pass
+
+    def unload(self):
+        '''Unload the actual video'''
+        self._state = ''
+
+
+# Load the appropriate provider
+video_providers = []
+try:
+    from kivy.lib.gstplayer import GstPlayer  # NOQA
+    video_providers += [('gstplayer', 'video_gstplayer', 'VideoGstplayer')]
+except ImportError:
+    pass
+video_providers += [
+    ('ffmpeg', 'video_ffmpeg', 'VideoFFMpeg'),
+    ('ffpyplayer', 'video_ffpyplayer', 'VideoFFPy'),
+    ('null', 'video_null', 'VideoNull')]
+
+
+Video = core_select_lib('video', video_providers)
diff --git a/kivy/core/video/__pycache__/__init__.cpython-310.pyc b/kivy/core/video/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..c80d68f
Binary files /dev/null and b/kivy/core/video/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/video/__pycache__/video_ffmpeg.cpython-310.pyc b/kivy/core/video/__pycache__/video_ffmpeg.cpython-310.pyc
new file mode 100644
index 0000000..3ca562e
Binary files /dev/null and b/kivy/core/video/__pycache__/video_ffmpeg.cpython-310.pyc differ
diff --git a/kivy/core/video/__pycache__/video_ffpyplayer.cpython-310.pyc b/kivy/core/video/__pycache__/video_ffpyplayer.cpython-310.pyc
new file mode 100644
index 0000000..982c04b
Binary files /dev/null and b/kivy/core/video/__pycache__/video_ffpyplayer.cpython-310.pyc differ
diff --git a/kivy/core/video/__pycache__/video_gstplayer.cpython-310.pyc b/kivy/core/video/__pycache__/video_gstplayer.cpython-310.pyc
new file mode 100644
index 0000000..66733e8
Binary files /dev/null and b/kivy/core/video/__pycache__/video_gstplayer.cpython-310.pyc differ
diff --git a/kivy/core/video/__pycache__/video_null.cpython-310.pyc b/kivy/core/video/__pycache__/video_null.cpython-310.pyc
new file mode 100644
index 0000000..f71ba1b
Binary files /dev/null and b/kivy/core/video/__pycache__/video_null.cpython-310.pyc differ
diff --git a/kivy/core/video/video_ffmpeg.py b/kivy/core/video/video_ffmpeg.py
new file mode 100644
index 0000000..59b19b5
--- /dev/null
+++ b/kivy/core/video/video_ffmpeg.py
@@ -0,0 +1,106 @@
+'''
+FFmpeg video abstraction
+========================
+
+.. versionadded:: 1.0.8
+
+This abstraction requires ffmpeg python extensions. We have made a special
+extension that is used for the android platform but can also be used on x86
+platforms. The project is available at::
+
+    http://github.com/tito/ffmpeg-android
+
+The extension is designed for implementing a video player.
+Refer to the documentation of the ffmpeg-android project for more information
+about the requirements.
+'''
+
+try:
+    import ffmpeg
+except:
+    raise
+
+from kivy.core.video import VideoBase
+from kivy.graphics.texture import Texture
+
+
+class VideoFFMpeg(VideoBase):
+
+    def __init__(self, **kwargs):
+        self._do_load = False
+        self._player = None
+        super(VideoFFMpeg, self).__init__(**kwargs)
+
+    def unload(self):
+        if self._player:
+            self._player.stop()
+            self._player = None
+        self._state = ''
+        self._do_load = False
+
+    def load(self):
+        self.unload()
+
+    def play(self):
+        if self._player:
+            self.unload()
+        self._player = ffmpeg.FFVideo(self._filename)
+        self._player.set_volume(self._volume)
+        self._do_load = True
+
+    def stop(self):
+        self.unload()
+
+    def seek(self, percent, precise=True):
+        if self._player is None:
+            return
+        self._player.seek(percent)
+
+    def _do_eos(self):
+        self.unload()
+        self.dispatch('on_eos')
+        super(VideoFFMpeg, self)._do_eos()
+
+    def _update(self, dt):
+        if self._do_load:
+            self._player.open()
+            self._do_load = False
+            return
+
+        player = self._player
+        if player is None:
+            return
+        if not player.is_open:
+            self._do_eos()
+            return
+
+        frame = player.get_next_frame()
+        if frame is None:
+            return
+
+        # first time we got a frame, we know that video is read now.
+        if self._texture is None:
+            self._texture = Texture.create(size=(
+                player.get_width(), player.get_height()),
+                colorfmt='rgb')
+            self._texture.flip_vertical()
+            self.dispatch('on_load')
+
+        if self._texture:
+            self._texture.blit_buffer(frame)
+            self.dispatch('on_frame')
+
+    def _get_duration(self):
+        if self._player is None:
+            return 0
+        return self._player.get_duration()
+
+    def _get_position(self):
+        if self._player is None:
+            return 0
+        return self._player.get_position()
+
+    def _set_volume(self, value):
+        self._volume = value
+        if self._player:
+            self._player.set_volume(self._volume)
diff --git a/kivy/core/video/video_ffpyplayer.py b/kivy/core/video/video_ffpyplayer.py
new file mode 100644
index 0000000..a14f8aa
--- /dev/null
+++ b/kivy/core/video/video_ffpyplayer.py
@@ -0,0 +1,446 @@
+'''
+FFmpeg based video abstraction
+==============================
+
+To use, you need to install ffpyplayer and have a compiled ffmpeg shared
+library.
+
+    https://github.com/matham/ffpyplayer
+
+The docs there describe how to set this up. But briefly, first you need to
+compile ffmpeg using the shared flags while disabling the static flags (you'll
+probably have to set the fPIC flag, e.g. CFLAGS=-fPIC). Here are some
+instructions: https://trac.ffmpeg.org/wiki/CompilationGuide. For Windows, you
+can download compiled GPL binaries from http://ffmpeg.zeranoe.com/builds/.
+Similarly, you should download SDL2.
+
+Now, you should have ffmpeg and sdl directories. In each, you should have an
+'include', 'bin' and 'lib' directory, where e.g. for Windows, 'lib' contains
+the .dll.a files, while 'bin' contains the actual dlls. The 'include' directory
+holds the headers. The 'bin' directory is only needed if the shared libraries
+are not already in the path. In the environment, define FFMPEG_ROOT and
+SDL_ROOT, each pointing to the ffmpeg and SDL directories respectively. (If
+you're using SDL2, the 'include' directory will contain an 'SDL2' directory,
+which then holds the headers).
+
+Once defined, download the ffpyplayer git repo and run
+
+    python setup.py build_ext --inplace
+
+Finally, before running you need to ensure that ffpyplayer is in python's path.
+
+..Note::
+
+    When kivy exits by closing the window while the video is playing,
+    it appears that the __del__method of VideoFFPy
+    is not called. Because of this, the VideoFFPy object is not
+    properly deleted when kivy exits. The consequence is that because
+    MediaPlayer creates internal threads which do not have their daemon
+    flag set, when the main threads exists, it'll hang and wait for the other
+    MediaPlayer threads to exit. But since __del__ is not called to delete the
+    MediaPlayer object, those threads will remain alive, hanging kivy. What
+    this means is that you have to be sure to delete the MediaPlayer object
+    before kivy exits by setting it to None.
+'''
+
+__all__ = ('VideoFFPy', )
+
+try:
+    import ffpyplayer
+    from ffpyplayer.player import MediaPlayer
+    from ffpyplayer.tools import set_log_callback, get_log_callback
+except:
+    raise
+
+
+from threading import Thread
+from queue import Queue, Empty, Full
+from kivy.clock import Clock, mainthread
+from kivy.logger import Logger
+from kivy.core.video import VideoBase
+from kivy.graphics import Rectangle, BindTexture
+from kivy.graphics.texture import Texture
+from kivy.graphics.fbo import Fbo
+from kivy.weakmethod import WeakMethod
+import time
+
+Logger.info('VideoFFPy: Using ffpyplayer {}'.format(ffpyplayer.version))
+
+
+logger_func = {'quiet': Logger.critical, 'panic': Logger.critical,
+               'fatal': Logger.critical, 'error': Logger.error,
+               'warning': Logger.warning, 'info': Logger.info,
+               'verbose': Logger.debug, 'debug': Logger.debug}
+
+
+def _log_callback(message, level):
+    message = message.strip()
+    if message:
+        logger_func[level]('ffpyplayer: {}'.format(message))
+
+
+if not get_log_callback():
+    set_log_callback(_log_callback)
+
+
+class VideoFFPy(VideoBase):
+
+    YUV_RGB_FS = """
+    $HEADER$
+    uniform sampler2D tex_y;
+    uniform sampler2D tex_u;
+    uniform sampler2D tex_v;
+
+    void main(void) {
+        float y = texture2D(tex_y, tex_coord0).r;
+        float u = texture2D(tex_u, tex_coord0).r - 0.5;
+        float v = texture2D(tex_v, tex_coord0).r - 0.5;
+        float r = y +             1.402 * v;
+        float g = y - 0.344 * u - 0.714 * v;
+        float b = y + 1.772 * u;
+        gl_FragColor = vec4(r, g, b, 1.0);
+    }
+    """
+
+    _trigger = None
+
+    def __init__(self, **kwargs):
+        self._ffplayer = None
+        self._thread = None
+        self._next_frame = None
+        self._seek_queue = []
+        self._ffplayer_need_quit = False
+        self._wakeup_queue = Queue(maxsize=1)
+        self._trigger = Clock.create_trigger(self._redraw)
+
+        super(VideoFFPy, self).__init__(**kwargs)
+
+    def __del__(self):
+        self.unload()
+
+    def _wakeup_thread(self):
+        try:
+            self._wakeup_queue.put(None, False)
+        except Full:
+            pass
+
+    def _wait_for_wakeup(self, timeout):
+        try:
+            self._wakeup_queue.get(True, timeout)
+        except Empty:
+            pass
+
+    def _player_callback(self, selector, value):
+        if self._ffplayer is None:
+            return
+        if selector == 'quit':
+            def close(*args):
+                self.unload()
+            Clock.schedule_once(close, 0)
+
+    def _get_position(self):
+        if self._ffplayer is not None:
+            return self._ffplayer.get_pts()
+        return 0
+
+    def _set_position(self, pos):
+        self.seek(pos)
+
+    def _set_volume(self, volume):
+        self._volume = volume
+        if self._ffplayer is not None:
+            self._ffplayer.set_volume(self._volume)
+
+    def _get_duration(self):
+        if self._ffplayer is None:
+            return 0
+        return self._ffplayer.get_metadata()['duration']
+
+    @mainthread
+    def _do_eos(self):
+        if self.eos == 'pause':
+            self.pause()
+        elif self.eos == 'stop':
+            self.stop()
+        elif self.eos == 'loop':
+            # this causes a seek to zero
+            self.position = 0
+
+        self.dispatch('on_eos')
+
+    @mainthread
+    def _finish_setup(self):
+        # once setup is done, we make sure player state matches what user
+        # could have requested while player was being setup and it was in limbo
+        # also, thread starts player in internal paused mode, so this unpauses
+        # it if user didn't request pause meanwhile
+        if self._ffplayer is not None:
+            self._ffplayer.set_volume(self._volume)
+            self._ffplayer.set_pause(self._state == 'paused')
+            self._wakeup_thread()
+
+    def _redraw(self, *args):
+        if not self._ffplayer:
+            return
+        next_frame = self._next_frame
+        if not next_frame:
+            return
+
+        img, pts = next_frame
+        if img.get_size() != self._size or self._texture is None:
+            self._size = w, h = img.get_size()
+
+            if self._out_fmt == 'yuv420p':
+                w2 = int(w / 2)
+                h2 = int(h / 2)
+                self._tex_y = Texture.create(
+                    size=(w, h), colorfmt='luminance')
+                self._tex_u = Texture.create(
+                    size=(w2, h2), colorfmt='luminance')
+                self._tex_v = Texture.create(
+                    size=(w2, h2), colorfmt='luminance')
+                self._fbo = fbo = Fbo(size=self._size)
+                with fbo:
+                    BindTexture(texture=self._tex_u, index=1)
+                    BindTexture(texture=self._tex_v, index=2)
+                    Rectangle(size=fbo.size, texture=self._tex_y)
+                fbo.shader.fs = VideoFFPy.YUV_RGB_FS
+                fbo['tex_y'] = 0
+                fbo['tex_u'] = 1
+                fbo['tex_v'] = 2
+                self._texture = fbo.texture
+            else:
+                self._texture = Texture.create(size=self._size,
+                                                colorfmt='rgba')
+
+            # XXX FIXME
+            # self.texture.add_reload_observer(self.reload_buffer)
+            self._texture.flip_vertical()
+            self.dispatch('on_load')
+
+        if self._texture:
+            if self._out_fmt == 'yuv420p':
+                dy, du, dv, _ = img.to_memoryview()
+                if dy and du and dv:
+                    self._tex_y.blit_buffer(dy, colorfmt='luminance')
+                    self._tex_u.blit_buffer(du, colorfmt='luminance')
+                    self._tex_v.blit_buffer(dv, colorfmt='luminance')
+                    self._fbo.ask_update()
+                    self._fbo.draw()
+            else:
+                self._texture.blit_buffer(
+                    img.to_memoryview()[0], colorfmt='rgba')
+
+            self.dispatch('on_frame')
+
+    def _next_frame_run(self, ffplayer):
+        sleep = time.sleep
+        trigger = self._trigger
+        did_dispatch_eof = False
+        wait_for_wakeup = self._wait_for_wakeup
+        seek_queue = self._seek_queue
+        # video starts in internal paused state
+
+        # fast path, if the source video is yuv420p, we'll use a glsl shader
+        # for buffer conversion to rgba
+        # wait until we get frame metadata
+        while not self._ffplayer_need_quit:
+            src_pix_fmt = ffplayer.get_metadata().get('src_pix_fmt')
+            if not src_pix_fmt:
+                wait_for_wakeup(0.005)
+                continue
+
+            if src_pix_fmt == 'yuv420p':
+                self._out_fmt = 'yuv420p'
+                ffplayer.set_output_pix_fmt(self._out_fmt)
+            break
+
+        if self._ffplayer_need_quit:
+            ffplayer.close_player()
+            return
+
+        # wait until loaded or failed, shouldn't take long, but just to make
+        # sure metadata is available.
+        while not self._ffplayer_need_quit:
+            if ffplayer.get_metadata()['src_vid_size'] != (0, 0):
+                break
+            wait_for_wakeup(0.005)
+
+        if self._ffplayer_need_quit:
+            ffplayer.close_player()
+            return
+
+        self._ffplayer = ffplayer
+        self._finish_setup()
+        # now, we'll be in internal paused state and loop will wait until
+        # mainthread unpauses us when finishing setup
+
+        while not self._ffplayer_need_quit:
+            seek_happened = False
+            if seek_queue:
+                vals = seek_queue[:]
+                del seek_queue[:len(vals)]
+                percent, precise = vals[-1]
+                ffplayer.seek(
+                    percent * ffplayer.get_metadata()['duration'],
+                    relative=False,
+                    accurate=precise
+                )
+                seek_happened = True
+                did_dispatch_eof = False
+                self._next_frame = None
+
+            # Get next frame if paused:
+            if seek_happened and ffplayer.get_pause():
+                ffplayer.set_volume(0.0)  # Try to do it silently.
+                ffplayer.set_pause(False)
+                try:
+                    # We don't know concrete number of frames to skip,
+                    # this number worked fine on couple of tested videos:
+                    to_skip = 6
+                    while True:
+                        frame, val = ffplayer.get_frame(show=False)
+                        # Exit loop on invalid val:
+                        if val in ('paused', 'eof'):
+                            break
+                        # Exit loop on seek_queue updated:
+                        if seek_queue:
+                            break
+                        # Wait for next frame:
+                        if frame is None:
+                            sleep(0.005)
+                            continue
+                        # Wait until we skipped enough frames:
+                        to_skip -= 1
+                        if to_skip == 0:
+                            break
+                    # Assuming last frame is actual, just get it:
+                    frame, val = ffplayer.get_frame(force_refresh=True)
+                finally:
+                    ffplayer.set_pause(bool(self._state == 'paused'))
+                    # todo: this is not safe because user could have updated
+                    # volume between us reading it and setting it
+                    ffplayer.set_volume(self._volume)
+            # Get next frame regular:
+            else:
+                frame, val = ffplayer.get_frame()
+
+            if val == 'eof':
+                if not did_dispatch_eof:
+                    self._do_eos()
+                    did_dispatch_eof = True
+                wait_for_wakeup(None)
+            elif val == 'paused':
+                did_dispatch_eof = False
+                wait_for_wakeup(None)
+            else:
+                did_dispatch_eof = False
+                if frame:
+                    self._next_frame = frame
+                    trigger()
+                else:
+                    val = val if val else (1 / 30.)
+                wait_for_wakeup(val)
+
+        ffplayer.close_player()
+
+    def seek(self, percent, precise=True):
+        # still save seek while thread is setting up
+        self._seek_queue.append((percent, precise,))
+        self._wakeup_thread()
+
+    def stop(self):
+        self.unload()
+
+    def pause(self):
+        # if state hasn't been set (empty), there's no player. If it's
+        # paused, nothing to do so just handle playing
+        if self._state == 'playing':
+            # we could be in limbo while player is setting up so check. Player
+            # will pause when finishing setting up
+            if self._ffplayer is not None:
+                self._ffplayer.set_pause(True)
+            # even in limbo, indicate to start in paused state
+            self._state = 'paused'
+            self._wakeup_thread()
+
+    def play(self):
+        # _state starts empty and is empty again after unloading
+        if self._ffplayer:
+            # player is already setup, just handle unpausing
+            assert self._state in ('paused', 'playing')
+            if self._state == 'paused':
+                self._ffplayer.set_pause(False)
+                self._state = 'playing'
+                self._wakeup_thread()
+            return
+
+        # we're now either in limbo state waiting for thread to setup,
+        # or no thread has been started
+        if self._state == 'playing':
+            # in limbo, just wait for thread to setup player
+            return
+        elif self._state == 'paused':
+            # in limbo, still unpause for when player becomes ready
+            self._state = 'playing'
+            self._wakeup_thread()
+            return
+
+        # load first unloads
+        self.load()
+        self._out_fmt = 'rgba'
+        # it starts internally paused, but unpauses itself
+        ff_opts = {
+            'paused': True,
+            'out_fmt': self._out_fmt,
+            'sn': True,
+            'volume': self._volume,
+        }
+        ffplayer = MediaPlayer(
+            self._filename, callback=self._player_callback,
+            thread_lib='SDL',
+            loglevel='info', ff_opts=ff_opts
+        )
+
+        # Disabled as an attempt to fix kivy issue #6210
+        # self._ffplayer.set_volume(self._volume)
+
+        self._thread = Thread(
+            target=self._next_frame_run,
+            name='Next frame',
+            args=(ffplayer, )
+        )
+        # todo: remove
+        self._thread.daemon = True
+
+        # start in playing mode, but _ffplayer isn't set until ready. We're
+        # now in a limbo state
+        self._state = 'playing'
+        self._thread.start()
+
+    def load(self):
+        self.unload()
+
+    def unload(self):
+        # no need to call self._trigger.cancel() because _ffplayer is set
+        # to None below, and it's not safe to call clock stuff from __del__
+
+        # if thread is still alive, set it to exit and wake it
+        self._wakeup_thread()
+        self._ffplayer_need_quit = True
+        # wait until it exits
+        if self._thread:
+            # TODO: use callback, don't block here
+            self._thread.join()
+            self._thread = None
+
+        if self._ffplayer:
+            self._ffplayer = None
+        self._next_frame = None
+        self._size = (0, 0)
+        self._state = ''
+        self._seek_queue = []
+
+        # reset for next load since thread is dead for sure
+        self._ffplayer_need_quit = False
+        self._wakeup_queue = Queue(maxsize=1)
diff --git a/kivy/core/video/video_gstplayer.py b/kivy/core/video/video_gstplayer.py
new file mode 100644
index 0000000..9bbed46
--- /dev/null
+++ b/kivy/core/video/video_gstplayer.py
@@ -0,0 +1,140 @@
+'''
+Video Gstplayer
+===============
+
+.. versionadded:: 1.8.0
+
+Implementation of a VideoBase with Kivy :class:`~kivy.lib.gstplayer.GstPlayer`
+This player is the preferred player, using Gstreamer 1.0, working on both
+Python 2 and 3.
+'''
+
+try:
+    from kivy.lib.gstplayer import GstPlayer, get_gst_version
+except ImportError:
+    from kivy.core import handle_win_lib_import_error
+    handle_win_lib_import_error(
+        'VideoGstplayer', 'gst', 'kivy.lib.gstplayer._gstplayer')
+    raise
+from kivy.graphics.texture import Texture
+from kivy.core.video import VideoBase
+from kivy.logger import Logger
+from kivy.clock import Clock
+from kivy.compat import PY2
+from threading import Lock
+from functools import partial
+from os.path import realpath
+from weakref import ref
+
+if PY2:
+    from urllib import pathname2url
+else:
+    from urllib.request import pathname2url
+
+Logger.info('VideoGstplayer: Using Gstreamer {}'.format(
+    '.'.join(map(str, get_gst_version()))))
+
+
+def _on_gstplayer_buffer(video, width, height, data):
+    video = video()
+    # if we still receive the video but no more player, remove it.
+    if not video:
+        return
+    with video._buffer_lock:
+        video._buffer = (width, height, data)
+
+
+def _on_gstplayer_message(mtype, message):
+    if mtype == 'error':
+        Logger.error('VideoGstplayer: {}'.format(message))
+    elif mtype == 'warning':
+        Logger.warning('VideoGstplayer: {}'.format(message))
+    elif mtype == 'info':
+        Logger.info('VideoGstplayer: {}'.format(message))
+
+
+class VideoGstplayer(VideoBase):
+
+    def __init__(self, **kwargs):
+        self.player = None
+        self._buffer = None
+        self._buffer_lock = Lock()
+        super(VideoGstplayer, self).__init__(**kwargs)
+
+    def _on_gst_eos_sync(self):
+        Clock.schedule_once(self._do_eos, 0)
+
+    def load(self):
+        Logger.debug('VideoGstplayer: Load <{}>'.format(self._filename))
+        uri = self._get_uri()
+        wk_self = ref(self)
+        self.player_callback = partial(_on_gstplayer_buffer, wk_self)
+        self.player = GstPlayer(uri, self.player_callback,
+                                self._on_gst_eos_sync, _on_gstplayer_message)
+        self.player.load()
+
+    def unload(self):
+        if self.player:
+            self.player.unload()
+            self.player = None
+        with self._buffer_lock:
+            self._buffer = None
+        self._texture = None
+
+    def stop(self):
+        super(VideoGstplayer, self).stop()
+        self.player.stop()
+
+    def pause(self):
+        super(VideoGstplayer, self).pause()
+        self.player.pause()
+
+    def play(self):
+        super(VideoGstplayer, self).play()
+        self.player.set_volume(self.volume)
+        self.player.play()
+
+    def seek(self, percent, precise=True):
+        self.player.seek(percent)
+
+    def _get_position(self):
+        return self.player.get_position()
+
+    def _get_duration(self):
+        return self.player.get_duration()
+
+    def _set_volume(self, value):
+        self._volume = value
+        if self.player:
+            self.player.set_volume(self._volume)
+
+    def _update(self, dt):
+        buf = None
+        with self._buffer_lock:
+            buf = self._buffer
+            self._buffer = None
+        if buf is not None:
+            self._update_texture(buf)
+            self.dispatch('on_frame')
+
+    def _update_texture(self, buf):
+        width, height, data = buf
+
+        # texture is not allocated yet, create it first
+        if not self._texture:
+            self._texture = Texture.create(size=(width, height),
+                                           colorfmt='rgb')
+            self._texture.flip_vertical()
+            self.dispatch('on_load')
+
+        if self._texture:
+            self._texture.blit_buffer(
+                data, size=(width, height), colorfmt='rgb')
+
+    def _get_uri(self):
+        uri = self.filename
+        if not uri:
+            return
+        if '://' not in uri:
+            uri = 'file:' + pathname2url(realpath(uri))
+        return uri
diff --git a/kivy/core/video/video_null.py b/kivy/core/video/video_null.py
new file mode 100644
index 0000000..7260a42
--- /dev/null
+++ b/kivy/core/video/video_null.py
@@ -0,0 +1,12 @@
+
+'''
+VideoNull: empty implementation of VideoBase for the no provider case
+'''
+
+from kivy.core.video import VideoBase
+
+
+class VideoNull(VideoBase):
+    '''VideoBase implementation when there is no provider.
+    '''
+    pass
diff --git a/kivy/core/window/__init__.py b/kivy/core/window/__init__.py
new file mode 100644
index 0000000..d03776a
--- /dev/null
+++ b/kivy/core/window/__init__.py
@@ -0,0 +1,2460 @@
+# pylint: disable=W0611
+# coding: utf-8
+'''
+Window
+======
+
+Core class for creating the default Kivy window. Kivy supports only one window
+per application: please don't try to create more than one.
+'''
+
+__all__ = ('Keyboard', 'WindowBase', 'Window')
+
+from os.path import join, exists
+from os import getcwd
+from collections import defaultdict
+
+from kivy.core import core_select_lib
+from kivy.clock import Clock
+from kivy.config import Config
+from kivy.logger import Logger
+from kivy.base import EventLoop, stopTouchApp
+from kivy.modules import Modules
+from kivy.event import EventDispatcher
+from kivy.properties import ListProperty, ObjectProperty, AliasProperty, \
+    NumericProperty, OptionProperty, StringProperty, BooleanProperty, \
+    ColorProperty
+from kivy.utils import platform, reify, deprecated, pi_version
+from kivy.context import get_current_context
+from kivy.uix.behaviors import FocusBehavior
+from kivy.setupconfig import USE_SDL2
+from kivy.graphics.transformation import Matrix
+from kivy.graphics.cgl import cgl_get_backend_name
+
+# late import
+VKeyboard = None
+android = None
+Animation = None
+
+
+class Keyboard(EventDispatcher):
+    '''Keyboard interface that is returned by
+    :meth:`WindowBase.request_keyboard`. When you request a keyboard,
+    you'll get an instance of this class. Whatever the keyboard input is
+    (system or virtual keyboard), you'll receive events through this
+    instance.
+
+    :Events:
+        `on_key_down`: keycode, text, modifiers
+            Fired when a new key is pressed down
+        `on_key_up`: keycode
+            Fired when a key is released (up)
+
+    Here is an example of how to request a Keyboard in accordance with the
+    current configuration:
+
+    .. include:: ../../examples/widgets/keyboardlistener.py
+        :literal:
+
+    '''
+
+    # Keycodes mapping, between str <-> int. These keycodes are
+    # currently taken from pygame.key. But when a new provider will be
+    # used, it must do the translation to these keycodes too.
+    keycodes = {
+        # specials keys
+        'backspace': 8, 'tab': 9, 'enter': 13, 'rshift': 303, 'shift': 304,
+        'alt': 308, 'rctrl': 306, 'lctrl': 305,
+        'super': 309, 'alt-gr': 307, 'compose': 311, 'pipe': 310,
+        'capslock': 301, 'escape': 27, 'spacebar': 32, 'pageup': 280,
+        'pagedown': 281, 'end': 279, 'home': 278, 'left': 276, 'up':
+        273, 'right': 275, 'down': 274, 'insert': 277, 'delete': 127,
+        'numlock': 300, 'print': 144, 'screenlock': 145, 'pause': 19,
+
+        # a-z keys
+        'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101, 'f': 102, 'g': 103,
+        'h': 104, 'i': 105, 'j': 106, 'k': 107, 'l': 108, 'm': 109, 'n': 110,
+        'o': 111, 'p': 112, 'q': 113, 'r': 114, 's': 115, 't': 116, 'u': 117,
+        'v': 118, 'w': 119, 'x': 120, 'y': 121, 'z': 122,
+
+        # 0-9 keys
+        '0': 48, '1': 49, '2': 50, '3': 51, '4': 52,
+        '5': 53, '6': 54, '7': 55, '8': 56, '9': 57,
+
+        # numpad
+        'numpad0': 256, 'numpad1': 257, 'numpad2': 258, 'numpad3': 259,
+        'numpad4': 260, 'numpad5': 261, 'numpad6': 262, 'numpad7': 263,
+        'numpad8': 264, 'numpad9': 265, 'numpaddecimal': 266,
+        'numpaddivide': 267, 'numpadmul': 268, 'numpadsubstract': 269,
+        'numpadadd': 270, 'numpadenter': 271,
+
+        # F1-15
+        'f1': 282, 'f2': 283, 'f3': 284, 'f4': 285, 'f5': 286, 'f6': 287,
+        'f7': 288, 'f8': 289, 'f9': 290, 'f10': 291, 'f11': 292, 'f12': 293,
+        'f13': 294, 'f14': 295, 'f15': 296,
+
+        # other keys
+        '(': 40, ')': 41,
+        '[': 91, ']': 93,
+        '{': 123, '}': 125,
+        ':': 58, ';': 59,
+        '=': 61, '+': 43,
+        '-': 45, '_': 95,
+        '/': 47, '*': 42,
+        '?': 47,
+        '`': 96, '~': 126,
+        '´': 180, '¦': 166,
+        '\\': 92, '|': 124,
+        '"': 34, "'": 39,
+        ',': 44, '.': 46,
+        '<': 60, '>': 62,
+        '@': 64, '!': 33,
+        '#': 35, '$': 36,
+        '%': 37, '^': 94,
+        '&': 38, '¬': 172,
+        '¨': 168, '…': 8230,
+        'ù': 249, 'à': 224,
+        'é': 233, 'è': 232,
+    }
+
+    __events__ = ('on_key_down', 'on_key_up', 'on_textinput')
+
+    def __init__(self, **kwargs):
+        super(Keyboard, self).__init__()
+
+        #: Window which the keyboard is attached too
+        self.window = kwargs.get('window', None)
+
+        #: Callback that will be called when the keyboard is released
+        self.callback = kwargs.get('callback', None)
+
+        #: Target that have requested the keyboard
+        self.target = kwargs.get('target', None)
+
+        #: VKeyboard widget, if allowed by the configuration
+        self.widget = kwargs.get('widget', None)
+
+    def on_key_down(self, keycode, text, modifiers):
+        pass
+
+    def on_key_up(self, keycode):
+        pass
+
+    def on_textinput(self, text):
+        pass
+
+    def release(self):
+        '''Call this method to release the current keyboard.
+        This will ensure that the keyboard is no longer attached to your
+        callback.'''
+        if self.window:
+            self.window.release_keyboard(self.target)
+            self.target = None
+
+    def _on_window_textinput(self, instance, text):
+        return self.dispatch('on_textinput', text)
+
+    def _on_window_key_down(self, instance, keycode, scancode, text,
+                            modifiers):
+        keycode = (keycode, self.keycode_to_string(keycode))
+        if text == '\x04':
+            Window.trigger_keyboard_height()
+            return
+        return self.dispatch('on_key_down', keycode, text, modifiers)
+
+    def _on_window_key_up(self, instance, keycode, *largs):
+        keycode = (keycode, self.keycode_to_string(keycode))
+        return self.dispatch('on_key_up', keycode)
+
+    def _on_vkeyboard_key_down(self, instance, keycode, text, modifiers):
+        if keycode is None:
+            keycode = text.lower()
+        keycode = (self.string_to_keycode(keycode), keycode)
+        return self.dispatch('on_key_down', keycode, text, modifiers)
+
+    def _on_vkeyboard_key_up(self, instance, keycode, text, modifiers):
+        if keycode is None:
+            keycode = text
+        keycode = (self.string_to_keycode(keycode), keycode)
+        return self.dispatch('on_key_up', keycode)
+
+    def _on_vkeyboard_textinput(self, instance, text):
+        return self.dispatch('on_textinput', text)
+
+    def string_to_keycode(self, value):
+        '''Convert a string to a keycode number according to the
+        :attr:`Keyboard.keycodes`. If the value is not found in the
+        keycodes, it will return -1.
+        '''
+        return Keyboard.keycodes.get(value, -1)
+
+    def keycode_to_string(self, value):
+        '''Convert a keycode number to a string according to the
+        :attr:`Keyboard.keycodes`. If the value is not found in the
+        keycodes, it will return ''.
+        '''
+        keycodes = list(Keyboard.keycodes.values())
+        if value in keycodes:
+            return list(Keyboard.keycodes.keys())[keycodes.index(value)]
+        return ''
+
+
+class WindowBase(EventDispatcher):
+    '''WindowBase is an abstract window widget for any window implementation.
+
+    :Parameters:
+        `borderless`: str, one of ('0', '1')
+            Set the window border state. Check the
+            :mod:`~kivy.config` documentation for a
+            more detailed explanation on the values.
+        `custom_titlebar`: str, one of ('0', '1')
+            Set to `'1'` to uses a custom titlebar
+        `fullscreen`: str, one of ('0', '1', 'auto', 'fake')
+            Make the window fullscreen. Check the
+            :mod:`~kivy.config` documentation for a
+            more detailed explanation on the values.
+        `width`: int
+            Width of the window.
+        `height`: int
+            Height of the window.
+        `minimum_width`: int
+            Minimum width of the window (only works for sdl2 window provider).
+        `minimum_height`: int
+            Minimum height of the window (only works for sdl2 window provider).
+        `allow_screensaver`: bool
+            Allow the device to show a screen saver, or to go to sleep
+            on mobile devices. Defaults to True. Only works for sdl2 window
+            provider.
+
+    :Events:
+        `on_motion`: etype, motionevent
+            Fired when a new :class:`~kivy.input.motionevent.MotionEvent` is
+            dispatched
+        `on_touch_down`:
+            Fired when a new touch event is initiated.
+        `on_touch_move`:
+            Fired when an existing touch event changes location.
+        `on_touch_up`:
+            Fired when an existing touch event is terminated.
+        `on_draw`:
+            Fired when the :class:`Window` is being drawn.
+        `on_flip`:
+            Fired when the :class:`Window` GL surface is being flipped.
+        `on_rotate`: rotation
+            Fired when the :class:`Window` is being rotated.
+        `on_close`:
+            Fired when the :class:`Window` is closed.
+        `on_request_close`:
+            Fired when the event loop wants to close the window, or if the
+            escape key is pressed and `exit_on_escape` is `True`. If a function
+            bound to this event returns `True`, the window will not be closed.
+            If the the event is triggered because of the keyboard escape key,
+            the keyword argument `source` is dispatched along with a value of
+            `keyboard` to the bound functions.
+
+            .. versionadded:: 1.9.0
+
+        `on_cursor_enter`:
+            Fired when the cursor enters the window.
+
+            .. versionadded:: 1.9.1
+
+        `on_cursor_leave`:
+            Fired when the cursor leaves the window.
+
+            .. versionadded:: 1.9.1
+
+        `on_minimize`:
+            Fired when the window is minimized.
+
+            .. versionadded:: 1.10.0
+
+        `on_maximize`:
+            Fired when the window is maximized.
+
+            .. versionadded:: 1.10.0
+
+        `on_restore`:
+            Fired when the window is restored.
+
+            .. versionadded:: 1.10.0
+
+        `on_hide`:
+            Fired when the window is hidden.
+
+            .. versionadded:: 1.10.0
+
+        `on_show`:
+            Fired when when the window is shown.
+
+            .. versionadded:: 1.10.0
+
+        `on_keyboard`: key, scancode, codepoint, modifier
+            Fired when the keyboard is used for input.
+
+            .. versionchanged:: 1.3.0
+                The *unicode* parameter has been deprecated in favor of
+                codepoint, and will be removed completely in future versions.
+
+        `on_key_down`: key, scancode, codepoint, modifier
+            Fired when a key pressed.
+
+            .. versionchanged:: 1.3.0
+                The *unicode* parameter has been deprecated in favor of
+                codepoint, and will be removed completely in future versions.
+
+        `on_key_up`: key, scancode, codepoint
+            Fired when a key is released.
+
+            .. versionchanged:: 1.3.0
+                The *unicode* parameter has be deprecated in favor of
+                codepoint, and will be removed completely in future versions.
+
+        `on_drop_begin`: x, y, *args
+            Fired when text(s) or file(s) drop on the application is about to
+            begin.
+
+            .. versionadded:: 2.1.0
+
+        `on_drop_file`: filename (bytes), x, y, *args
+            Fired when a file is dropped on the application.
+
+            .. versionadded:: 1.2.0
+
+            .. versionchanged:: 2.1.0
+                Renamed from `on_dropfile` to `on_drop_file`.
+
+        `on_drop_text`: text (bytes), x, y, *args
+            Fired when a text is dropped on the application.
+
+            .. versionadded:: 2.1.0
+
+        `on_drop_end`: x, y, *args
+            Fired when text(s) or file(s) drop on the application has ended.
+
+            .. versionadded:: 2.1.0
+
+        `on_memorywarning`:
+            Fired when the platform have memory issue (iOS / Android mostly)
+            You can listen to this one, and clean whatever you can.
+
+            .. versionadded:: 1.9.0
+
+        `on_textedit(self, text)`:
+            Fired when inputting with IME.
+            The string inputting with IME is set as the parameter of
+            this event.
+
+            .. versionadded:: 1.10.1
+    '''
+
+    __instance = None
+    __initialized = False
+    _fake_fullscreen = False
+
+    # private properties
+    _density = NumericProperty(1.)
+    _size = ListProperty([0, 0])
+    _modifiers = ListProperty([])
+    _rotation = NumericProperty(0)
+    _focus = BooleanProperty(True)
+
+    gl_backends_allowed = []
+    """
+    A list of Kivy gl backend names, which if not empty, will be the
+    exclusive list of gl backends that can be used with this window.
+    """
+
+    gl_backends_ignored = []
+    """
+    A list of Kivy gl backend names that may not be used with this window.
+    """
+
+    managed_textinput = False
+    """
+    True if this Window class uses `on_textinput` to insert text, internal.
+    """
+
+    children = ListProperty([])
+    '''List of the children of this window.
+
+    :attr:`children` is a :class:`~kivy.properties.ListProperty` instance and
+    defaults to an empty list.
+
+    Use :meth:`add_widget` and :meth:`remove_widget` to manipulate the list of
+    children. Don't manipulate the list directly unless you know what you are
+    doing.
+    '''
+
+    parent = ObjectProperty(None, allownone=True)
+    '''Parent of this window.
+
+    :attr:`parent` is a :class:`~kivy.properties.ObjectProperty` instance and
+    defaults to None. When created, the parent is set to the window itself.
+    You must take care of it if you are doing a recursive check.
+    '''
+
+    icon = StringProperty()
+    '''A path to the window icon.
+
+    .. versionadded:: 1.1.2
+
+    :attr:`icon` is a :class:`~kivy.properties.StringProperty`.
+    '''
+
+    def _get_modifiers(self):
+        return self._modifiers
+
+    modifiers = AliasProperty(_get_modifiers, None, bind=('_modifiers',))
+    '''List of keyboard modifiers currently active.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`modifiers` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_size(self):
+        r = self._rotation
+        w, h = self._size
+        if self._density != 1:
+            w, h = self._win._get_gl_size()
+        if self.softinput_mode == 'resize':
+            h -= self.keyboard_height
+        if r in (0, 180):
+            return w, h
+        return h, w
+
+    def _set_size(self, size):
+        if self._size != size:
+            r = self._rotation
+            if r in (0, 180):
+                self._size = size
+            else:
+                self._size = size[1], size[0]
+            self.dispatch('on_pre_resize', *size)
+
+    minimum_width = NumericProperty(0)
+    '''The minimum width to restrict the window to.
+
+    .. versionadded:: 1.9.1
+
+    :attr:`minimum_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    minimum_height = NumericProperty(0)
+    '''The minimum height to restrict the window to.
+
+    .. versionadded:: 1.9.1
+
+    :attr:`minimum_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    allow_screensaver = BooleanProperty(True)
+    '''Whether the screen saver is enabled, or on mobile devices whether the
+    device is allowed to go to sleep while the app is open.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`allow_screensaver` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True.
+    '''
+
+    size = AliasProperty(_get_size, _set_size, bind=('_size', '_rotation'))
+    '''Get the rotated size of the window. If :attr:`rotation` is set, then the
+    size will change to reflect the rotation.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`size` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    clearcolor = ColorProperty((0, 0, 0, 1))
+    '''Color used to clear the window.
+
+    ::
+
+        from kivy.core.window import Window
+
+        # red background color
+        Window.clearcolor = (1, 0, 0, 1)
+
+        # don't clear background at all
+        Window.clearcolor = None
+
+    .. versionchanged:: 1.7.2
+        The clearcolor default value is now: (0, 0, 0, 1).
+
+    .. versionadded:: 1.0.9
+
+    :attr:`clearcolor` is an :class:`~kivy.properties.ColorProperty` and
+    defaults to (0, 0, 0, 1).
+
+    .. versionchanged:: 2.1.0
+        Changed from :class:`~kivy.properties.AliasProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    # make some property read-only
+    def _get_width(self):
+        _size = self._size
+        if self._density != 1:
+            _size = self._win._get_gl_size()
+        r = self._rotation
+        if r == 0 or r == 180:
+            return _size[0]
+        return _size[1]
+
+    width = AliasProperty(_get_width, bind=('_rotation', '_size', '_density'))
+    '''Rotated window width.
+
+    :attr:`width` is a read-only :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_height(self):
+        '''Rotated window height'''
+        r = self._rotation
+        _size = self._size
+        if self._density != 1:
+            _size = self._win._get_gl_size()
+        kb = self.keyboard_height if self.softinput_mode == 'resize' else 0
+        if r == 0 or r == 180:
+            return _size[1] - kb
+        return _size[0] - kb
+
+    height = AliasProperty(_get_height,
+                           bind=('_rotation', '_size', '_density'))
+    '''Rotated window height.
+
+    :attr:`height` is a read-only :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_center(self):
+        return self.width / 2., self.height / 2.
+
+    center = AliasProperty(_get_center, bind=('width', 'height'))
+    '''Center of the rotated window.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`center` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_rotation(self):
+        return self._rotation
+
+    def _set_rotation(self, x):
+        x = int(x % 360)
+        if x == self._rotation:
+            return
+        if x not in (0, 90, 180, 270):
+            raise ValueError('can rotate only 0, 90, 180, 270 degrees')
+        self._rotation = x
+        if not self.initialized:
+            return
+        self.dispatch('on_pre_resize', *self.size)
+        self.dispatch('on_rotate', x)
+
+    rotation = AliasProperty(_get_rotation, _set_rotation,
+                             bind=('_rotation', ))
+    '''Get/set the window content rotation. Can be one of 0, 90, 180, 270
+    degrees.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`rotation` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    softinput_mode = OptionProperty(
+        '', options=('', 'below_target', 'pan', 'scale', 'resize')
+    )
+    '''This specifies the behavior of window contents on display of the soft
+    keyboard on mobile platforms. It can be one of '', 'pan', 'scale',
+    'resize' or 'below_target'. Their effects are listed below.
+
+    +----------------+-------------------------------------------------------+
+    | Value          | Effect                                                |
+    +================+=======================================================+
+    | ''             | The main window is left as is, allowing you to use    |
+    |                | the :attr:`keyboard_height` to manage the window      |
+    |                | contents manually.                                    |
+    +----------------+-------------------------------------------------------+
+    | 'pan'          | The main window pans, moving the bottom part of the   |
+    |                | window to be always on top of the keyboard.           |
+    +----------------+-------------------------------------------------------+
+    | 'resize'       | The window is resized and the contents scaled to fit  |
+    |                | the remaining space.                                  |
+    +----------------+-------------------------------------------------------+
+    | 'below_target' | The window pans so that the current target TextInput  |
+    |                | widget requesting the keyboard is presented just above|
+    |                | the soft keyboard.                                    |
+    +----------------+-------------------------------------------------------+
+
+    :attr:`softinput_mode` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to ''.
+
+    .. note:: The `resize` option does not currently work with SDL2 on Android.
+
+    .. versionadded:: 1.9.0
+
+    .. versionchanged:: 1.9.1
+        The 'below_target' option was added.
+    '''
+
+    _keyboard_changed = BooleanProperty(False)
+    _kheight = NumericProperty(0)
+    _kanimation = None
+
+    def _free_kanimation(self, *largs):
+        WindowBase._kanimation = None
+
+    def _animate_content(self):
+        '''Animate content to IME height.
+        '''
+        kargs = self.keyboard_anim_args
+        global Animation
+        if not Animation:
+            from kivy.animation import Animation
+        if WindowBase._kanimation:
+            WindowBase._kanimation.cancel(self)
+        WindowBase._kanimation = kanim = Animation(
+            _kheight=self.keyboard_height + self.keyboard_padding,
+            d=kargs['d'], t=kargs['t'])
+        kanim.bind(on_complete=self._free_kanimation)
+        kanim.start(self)
+
+    def _upd_kbd_height(self, *kargs):
+        self._keyboard_changed = not self._keyboard_changed
+        self._animate_content()
+
+    def _get_ios_kheight(self):
+        import ios
+        return ios.get_kheight()
+
+    def _get_android_kheight(self):
+        if USE_SDL2:  # Placeholder until the SDL2 bootstrap supports this
+            return 0
+        global android
+        if not android:
+            import android
+        return android.get_keyboard_height()
+
+    def _get_kivy_vkheight(self):
+        mode = Config.get('kivy', 'keyboard_mode')
+        if (
+            mode in ['dock', 'systemanddock']
+            and self._vkeyboard_cls is not None
+        ):
+            for w in self.children:
+                if isinstance(w, VKeyboard):
+                    vkeyboard_height = w.height * w.scale
+                    if self.softinput_mode == 'pan':
+                        return vkeyboard_height
+                    elif (
+                        self.softinput_mode == 'below_target'
+                        and w.target.y < vkeyboard_height
+                    ):
+                        return vkeyboard_height - w.target.y
+        return 0
+
+    def _get_kheight(self):
+        if platform == 'android':
+            return self._get_android_kheight()
+        elif platform == 'ios':
+            return self._get_ios_kheight()
+        return self._get_kivy_vkheight()
+
+    keyboard_height = AliasProperty(_get_kheight, bind=('_keyboard_changed',))
+    '''Returns the height of the softkeyboard/IME on mobile platforms.
+    Will return 0 if not on mobile platform or if IME is not active.
+
+    .. note:: This property returns 0 with SDL2 on Android, but setting
+              Window.softinput_mode does work.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`keyboard_height` is a read-only
+    :class:`~kivy.properties.AliasProperty` and defaults to 0.
+    '''
+
+    keyboard_anim_args = {'t': 'in_out_quart', 'd': .5}
+    '''The attributes for animating softkeyboard/IME.
+    `t` = `transition`, `d` = `duration`. This value will have no effect on
+    desktops.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`keyboard_anim_args` is a dict and defaults to
+    {'t': 'in_out_quart', 'd': `.5`}.
+    '''
+
+    keyboard_padding = NumericProperty(0)
+    '''The padding to have between the softkeyboard/IME & target
+    or bottom of window. Will have no effect on desktops.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`keyboard_padding` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to 0.
+    '''
+
+    def _set_system_size(self, size):
+        self._size = size
+
+    def _get_system_size(self):
+        if self.softinput_mode == 'resize':
+            return self._size[0], self._size[1] - self.keyboard_height
+        return self._size
+
+    system_size = AliasProperty(_get_system_size, _set_system_size,
+                                bind=('_size',))
+    '''Real size of the window ignoring rotation. If the density is
+    not 1, the :attr:`system_size` is the :attr:`size` divided by
+    density.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`system_size` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_effective_size(self):
+        '''On density=1 and non-ios displays, return :attr:`system_size`,
+        else return scaled / rotated :attr:`size`.
+
+        Used by MouseMotionEvent.update_graphics() and WindowBase.on_motion().
+        '''
+        w, h = self.system_size
+        if platform == 'ios' or self._density != 1:
+            w, h = self.size
+
+        return w, h
+
+    borderless = BooleanProperty(False)
+    '''When set to True, this property removes the window border/decoration.
+    Check the :mod:`~kivy.config` documentation for a more detailed
+    explanation on the values.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`borderless` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    custom_titlebar = BooleanProperty(False)
+    '''When set to True, allows the user to set a widget as a titlebar.
+    Check the :mod:`~kivy.config` documentation for a more detailed
+    explanation on the values.
+
+    .. versionadded:: 2.1.0
+
+    see :meth:`~kivy.core.window.WindowBase.set_custom_titlebar`
+    for detailed usage
+    :attr:`custom_titlebar` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    fullscreen = OptionProperty(False, options=(True, False, 'auto', 'fake'))
+    '''This property sets the fullscreen mode of the window. Available options
+    are: True, False, 'auto' and 'fake'. Check the :mod:`~kivy.config`
+    documentation for more detailed explanations on these values.
+
+    fullscreen is an :class:`~kivy.properties.OptionProperty` and defaults to
+    `False`.
+
+    .. versionadded:: 1.2.0
+
+    .. note::
+        The 'fake' option has been deprecated, use the :attr:`borderless`
+        property instead.
+    '''
+
+    mouse_pos = ObjectProperty((0, 0))
+    '''2d position of the mouse cursor within the window.
+
+    Position is relative to the left/bottom point of the window.
+
+    .. note::
+        Cursor position will be scaled by the pixel density if the high density
+        mode is supported by the window provider.
+
+    .. versionadded:: 1.2.0
+
+    :attr:`mouse_pos` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to (0, 0).
+    '''
+
+    show_cursor = BooleanProperty(True)
+    '''Set whether or not the cursor is shown on the window.
+
+    .. versionadded:: 1.9.1
+
+    :attr:`show_cursor` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    def _get_focus(self):
+        return self._focus
+
+    focus = AliasProperty(_get_focus, None, bind=('_focus',))
+    '''Check whether or not the window currently has focus.
+
+    .. versionadded:: 1.9.1
+
+    :attr:`focus` is a read-only :class:`~kivy.properties.AliasProperty` and
+    defaults to True.
+    '''
+
+    def _set_cursor_state(self, value):
+        pass
+
+    def set_system_cursor(self, cursor_name):
+        '''Set type of a mouse cursor in the Window.
+
+        It can be one of 'arrow', 'ibeam', 'wait', 'crosshair', 'wait_arrow',
+        'size_nwse', 'size_nesw', 'size_we', 'size_ns', 'size_all', 'no', or
+        'hand'.
+
+        On some platforms there might not be a specific cursor supported and
+        such an option falls back to one of the substitutable alternatives:
+
+        +------------+-----------+------------+-----------+---------------+
+        |            | Windows   | MacOS      | Linux X11 | Linux Wayland |
+        +============+===========+============+===========+===============+
+        | arrow      | arrow     | arrow      | arrow     | arrow         |
+        +------------+-----------+------------+-----------+---------------+
+        | ibeam      | ibeam     | ibeam      | ibeam     | ibeam         |
+        +------------+-----------+------------+-----------+---------------+
+        | wait       | wait      | arrow      | wait      | wait          |
+        +------------+-----------+------------+-----------+---------------+
+        | crosshair  | crosshair | crosshair  | crosshair | hand          |
+        +------------+-----------+------------+-----------+---------------+
+        | wait_arrow | arrow     | arrow      | wait      | wait          |
+        +------------+-----------+------------+-----------+---------------+
+        | size_nwse  | size_nwse | size_all   | size_all  | hand          |
+        +------------+-----------+------------+-----------+---------------+
+        | size_nesw  | size_nesw | size_all   | size_all  | hand          |
+        +------------+-----------+------------+-----------+---------------+
+        | size_we    | size_we   | size_we    | size_we   | hand          |
+        +------------+-----------+------------+-----------+---------------+
+        | size_ns    | size_ns   | size_ns    | size_ns   | hand          |
+        +------------+-----------+------------+-----------+---------------+
+        | size_all   | size_all  | size_all   | size_all  | hand          |
+        +------------+-----------+------------+-----------+---------------+
+        | no         | no        | no         | no        | ibeam         |
+        +------------+-----------+------------+-----------+---------------+
+        | hand       | hand      | hand       | hand      | hand          |
+        +------------+-----------+------------+-----------+---------------+
+
+        .. versionadded:: 1.10.1
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+        '''
+        pass
+
+    def _get_window_pos(self):
+        pass
+
+    def _set_window_pos(self, x, y):
+        pass
+
+    def _get_left(self):
+        if not self.initialized:
+            return self._left
+        return self._get_window_pos()[0]
+
+    def _set_left(self, value):
+        pos = self._get_window_pos()
+        self._set_window_pos(value, pos[1])
+
+    def _get_top(self):
+        if not self.initialized:
+            return self._top
+        return self._get_window_pos()[1]
+
+    def _set_top(self, value):
+        pos = self._get_window_pos()
+        self._set_window_pos(pos[0], value)
+
+    top = AliasProperty(_get_top, _set_top)
+    '''Top position of the window.
+
+    .. note:: It's an SDL2 property with `[0, 0]` in the top-left corner.
+
+    .. versionchanged:: 1.10.0
+        :attr:`top` is now an :class:`~kivy.properties.AliasProperty`
+
+    .. versionadded:: 1.9.1
+
+    :attr:`top` is an :class:`~kivy.properties.AliasProperty` and defaults to
+    the position set in :class:`~kivy.config.Config`.
+    '''
+
+    left = AliasProperty(_get_left, _set_left)
+    '''Left position of the window.
+
+    .. note:: It's an SDL2 property with `[0, 0]` in the top-left corner.
+
+    .. versionchanged:: 1.10.0
+        :attr:`left` is now an :class:`~kivy.properties.AliasProperty`
+
+    .. versionadded:: 1.9.1
+
+    :attr:`left` is an :class:`~kivy.properties.AliasProperty` and defaults to
+    the position set in :class:`~kivy.config.Config`.
+    '''
+
+    @property
+    def __self__(self):
+        return self
+
+    position = OptionProperty('auto', options=['auto', 'custom'])
+    render_context = ObjectProperty(None)
+    canvas = ObjectProperty(None)
+    title = StringProperty('Kivy')
+
+    event_managers = None
+    '''Holds a `list` of registered event managers.
+
+    Don't change the property directly but use
+    :meth:`register_event_manager` and :meth:`unregister_event_manager` to
+    register and unregister an event manager.
+
+    Event manager is an instance of
+    :class:`~kivy.eventmanager.EventManagerBase`.
+
+    .. versionadded:: 2.1.0
+
+    .. warning::
+        This is an experimental property and it remains so while this warning
+        is present.
+    '''
+
+    event_managers_dict = None
+    '''Holds a `dict` of `type_id` to `list` of event managers.
+
+    Don't change the property directly but use
+    :meth:`register_event_manager` and :meth:`unregister_event_manager` to
+    register and unregister an event manager.
+
+    Event manager is an instance of
+    :class:`~kivy.eventmanager.EventManagerBase`.
+
+    .. versionadded:: 2.1.0
+
+    .. warning::
+        This is an experimental property and it remains so while this warning
+        is present.
+    '''
+
+    trigger_create_window = None
+
+    __events__ = (
+        'on_draw', 'on_flip', 'on_rotate', 'on_resize', 'on_move',
+        'on_close', 'on_minimize', 'on_maximize', 'on_restore',
+        'on_hide', 'on_show', 'on_motion', 'on_touch_down',
+        'on_touch_move', 'on_touch_up', 'on_mouse_down',
+        'on_mouse_move', 'on_mouse_up', 'on_keyboard', 'on_key_down',
+        'on_key_up', 'on_textinput', 'on_drop_begin', 'on_drop_file',
+        'on_dropfile', 'on_drop_text', 'on_drop_end', 'on_request_close',
+        'on_cursor_enter', 'on_cursor_leave', 'on_joy_axis',
+        'on_joy_hat', 'on_joy_ball', 'on_joy_button_down',
+        'on_joy_button_up', 'on_memorywarning', 'on_textedit',
+        # internal
+        'on_pre_resize')
+
+    def __new__(cls, **kwargs):
+        if cls.__instance is None:
+            cls.__instance = EventDispatcher.__new__(cls)
+        return cls.__instance
+
+    def __init__(self, **kwargs):
+        force = kwargs.pop('force', False)
+
+        # don't init window 2 times,
+        # except if force is specified
+        if WindowBase.__instance is not None and not force:
+            return
+
+        self.initialized = False
+        self.event_managers = []
+        self.event_managers_dict = defaultdict(list)
+        self._is_desktop = Config.getboolean('kivy', 'desktop')
+
+        # create a trigger for update/create the window when one of window
+        # property changes
+        self.trigger_create_window = Clock.create_trigger(
+            self.create_window, -1)
+
+        # Create a trigger for updating the keyboard height
+        self.trigger_keyboard_height = Clock.create_trigger(
+            self._upd_kbd_height, .5)
+        self.bind(_kheight=lambda *args: self.update_viewport())
+
+        # set the default window parameter according to the configuration
+        if 'borderless' not in kwargs:
+            kwargs['borderless'] = Config.getboolean('graphics', 'borderless')
+        if 'custom_titlebar' not in kwargs:
+            kwargs['custom_titlebar'] = Config.getboolean('graphics',
+                                                          'custom_titlebar')
+        if 'fullscreen' not in kwargs:
+            fullscreen = Config.get('graphics', 'fullscreen')
+            if fullscreen not in ('auto', 'fake'):
+                fullscreen = fullscreen.lower() in ('true', '1', 'yes')
+            kwargs['fullscreen'] = fullscreen
+        if 'width' not in kwargs:
+            kwargs['width'] = Config.getint('graphics', 'width')
+        if 'height' not in kwargs:
+            kwargs['height'] = Config.getint('graphics', 'height')
+        if 'minimum_width' not in kwargs:
+            kwargs['minimum_width'] = Config.getint('graphics',
+                                                    'minimum_width')
+        if 'minimum_height' not in kwargs:
+            kwargs['minimum_height'] = Config.getint('graphics',
+                                                     'minimum_height')
+        if 'allow_screensaver' not in kwargs:
+            kwargs['allow_screensaver'] = Config.getboolean(
+                'graphics', 'allow_screensaver')
+        if 'rotation' not in kwargs:
+            kwargs['rotation'] = Config.getint('graphics', 'rotation')
+        if 'position' not in kwargs:
+            kwargs['position'] = Config.getdefault('graphics', 'position',
+                                                   'auto')
+        if 'top' in kwargs:
+            kwargs['position'] = 'custom'
+            self._top = kwargs['top']
+        else:
+            self._top = Config.getint('graphics', 'top')
+        if 'left' in kwargs:
+            kwargs['position'] = 'custom'
+            self._left = kwargs['left']
+        else:
+            self._left = Config.getint('graphics', 'left')
+        kwargs['_size'] = (kwargs.pop('width'), kwargs.pop('height'))
+        if 'show_cursor' not in kwargs:
+            kwargs['show_cursor'] = Config.getboolean(
+                'graphics', 'show_cursor'
+            )
+        if 'shape_image' not in kwargs:
+            kwargs['shape_image'] = Config.get('kivy', 'window_shape')
+
+        self.fbind(
+            'on_drop_file',
+            lambda win, filename, *args: win.dispatch('on_dropfile', filename)
+        )
+        super(WindowBase, self).__init__(**kwargs)
+
+        # bind all the properties that need to recreate the window
+        self._bind_create_window()
+        self.bind(size=self.trigger_keyboard_height,
+                  rotation=self.trigger_keyboard_height)
+
+        self.bind(softinput_mode=lambda *dt: self.update_viewport(),
+                  keyboard_height=lambda *dt: self.update_viewport())
+
+        self.bind(show_cursor=lambda *dt: self._set_cursor_state(dt[1]))
+
+        # init privates
+        self._system_keyboard = Keyboard(window=self)
+        self._keyboards = {'system': self._system_keyboard}
+        self._vkeyboard_cls = None
+
+        self.children = []
+        self.parent = self
+
+        # before creating the window
+        import kivy.core.gl  # NOQA
+
+        # configure the window
+        self.create_window()
+        self.register()
+
+        # manage keyboard(s)
+        self.configure_keyboards()
+
+        # assign the default context of the widget creation
+        if not hasattr(self, '_context'):
+            self._context = get_current_context()
+
+        # because Window is created as soon as imported, if we bound earlier,
+        # metrics would be imported when dp is set during window creation.
+        # Instead, don't process dpi changes until everything is set
+        self.fbind('dpi', self._reset_metrics_dpi)
+
+        # mark as initialized
+        self.initialized = True
+
+    def _reset_metrics_dpi(self, *args):
+        from kivy.metrics import Metrics
+        Metrics.reset_dpi()
+
+    def _bind_create_window(self):
+        for prop in (
+                'fullscreen', 'borderless', 'position', 'top',
+                'left', '_size', 'system_size'):
+            self.bind(**{prop: self.trigger_create_window})
+
+    def _unbind_create_window(self):
+        for prop in (
+                'fullscreen', 'borderless', 'position', 'top',
+                'left', '_size', 'system_size'):
+            self.unbind(**{prop: self.trigger_create_window})
+
+    def register(self):
+        if self.initialized:
+            return
+        # attach modules + listener event
+        EventLoop.set_window(self)
+        Modules.register_window(self)
+        EventLoop.add_event_listener(self)
+
+    def register_event_manager(self, manager):
+        '''Register and start an event manager to handle events declared in
+        :attr:`~kivy.eventmanager.EventManagerBase.type_ids` attribute.
+
+        .. versionadded:: 2.1.0
+
+        .. warning::
+            This is an experimental method and it remains so until this warning
+            is present as it can be changed or removed in the next versions of
+            Kivy.
+        '''
+        self.event_managers.insert(0, manager)
+        for type_id in manager.type_ids:
+            self.event_managers_dict[type_id].insert(0, manager)
+        manager.window = self
+        manager.start()
+
+    def unregister_event_manager(self, manager):
+        '''Unregister and stop an event manager previously registered with
+        :meth:`register_event_manager`.
+
+        .. versionadded:: 2.1.0
+
+        .. warning::
+            This is an experimental method and it remains so until this warning
+            is present as it can be changed or removed in the next versions of
+            Kivy.
+        '''
+        self.event_managers.remove(manager)
+        for type_id in manager.type_ids:
+            self.event_managers_dict[type_id].remove(manager)
+        manager.stop()
+        manager.window = None
+
+    def mainloop(self):
+        '''Called by the EventLoop every frame after it idles.
+        '''
+        pass
+
+    @deprecated
+    def toggle_fullscreen(self):
+        '''Toggle between fullscreen and windowed mode.
+
+        .. deprecated:: 1.9.0
+            Use :attr:`fullscreen` instead.
+        '''
+        pass
+
+    def maximize(self):
+        '''Maximizes the window. This method should be used on desktop
+        platforms only.
+
+        .. versionadded:: 1.9.0
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+        '''
+        Logger.warning('Window: maximize() is not implemented in the current '
+                        'window provider.')
+
+    def minimize(self):
+        '''Minimizes the window. This method should be used on desktop
+        platforms only.
+
+        .. versionadded:: 1.9.0
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+        '''
+        Logger.warning('Window: minimize() is not implemented in the current '
+                        'window provider.')
+
+    def restore(self):
+        '''Restores the size and position of a maximized or minimized window.
+        This method should be used on desktop platforms only.
+
+        .. versionadded:: 1.9.0
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+        '''
+        Logger.warning('Window: restore() is not implemented in the current '
+                        'window provider.')
+
+    def hide(self):
+        '''Hides the window. This method should be used on desktop
+        platforms only.
+
+        .. versionadded:: 1.9.0
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+        '''
+        Logger.warning('Window: hide() is not implemented in the current '
+                        'window provider.')
+
+    def show(self):
+        '''Shows the window. This method should be used on desktop
+        platforms only.
+
+        .. versionadded:: 1.9.0
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+        '''
+        Logger.warning('Window: show() is not implemented in the current '
+                        'window provider.')
+
+    def raise_window(self):
+        '''Raise the window. This method should be used on desktop
+        platforms only.
+
+        .. versionadded:: 1.9.1
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+        '''
+        Logger.warning('Window: raise_window is not implemented in the current'
+                       ' window provider.')
+
+    def close(self):
+        '''Close the window'''
+        self.dispatch('on_close')
+
+        # Prevent any leftover that can crash the app later
+        # like if there is still some GL referenced values
+        # they may be collected later, but because it was already
+        # gone in the system, it may collect invalid GL resources
+        # Just clear everything to force reloading later on.
+        from kivy.cache import Cache
+        from kivy.graphics.context import get_context
+        Cache.remove('kv.loader')
+        Cache.remove('kv.image')
+        Cache.remove('kv.shader')
+        Cache.remove('kv.texture')
+        get_context().flush()
+
+    shape_image = StringProperty('')
+    '''An image for the window shape (only works for sdl2 window provider).
+
+    .. warning:: The image size has to be the same like the window's size!
+
+    .. versionadded:: 1.10.1
+
+    :attr:`shape_image` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'data/images/defaultshape.png'. This value is taken from
+    :class:`~kivy.config.Config`.
+    '''
+    def set_custom_titlebar(self, widget):
+        """
+        Sets a Widget as a titlebar
+
+            :widget: The widget you want to set as the titlebar
+
+        .. versionadded:: 2.1.0
+
+        This function returns `True` on successfully setting the custom titlebar,
+        else false
+
+        How to use this feature
+
+        ::
+
+            1. first set Window.custom_titlebar to True
+            2. then call Window.set_custom_titlebar with the widget/layout you want to set as titlebar as the argument # noqa: E501
+
+        If you want a child of the widget to receive touch events, in
+        that child define a property `draggable` and set it to False
+
+        If you set the property `draggable` on a layout,
+        all the child in the layout will receive touch events
+
+        If you want to override default behaviour, add function `in_drag_area(x,y)`
+        to the widget
+
+        The function is call with two args x,y which are mouse.x, and mouse.y
+        the function should return
+
+        | `True` if that point should be used to drag the window
+        | `False` if you want to receive the touch event at the point
+
+        .. note::
+            If you use :meth:`in_drag_area` property `draggable`
+            will not be checked
+
+        .. note::
+            This feature requires the SDL2 window provider and is currently
+            only supported on desktop platforms.
+
+        .. warning::
+            :mod:`~kivy.core.window.WindowBase.custom_titlebar` must be set to True
+            for the widget to be successfully set as a titlebar
+
+        """
+
+        Logger.warning('Window: set_custom_titlebar '
+                       'is not implemented in the current'
+                       ' window provider.')
+
+    def on_shape_image(self, instance, value):
+        if self.initialized:
+            self._set_shape(
+                shape_image=value, mode=self.shape_mode,
+                cutoff=self.shape_cutoff, color_key=self.shape_color_key
+            )
+
+    shape_cutoff = BooleanProperty(True)
+    '''The window :attr:`shape_image` cutoff property (only works for sdl2
+    window provider).
+
+    .. versionadded:: 1.10.1
+
+    :attr:`shape_cutoff` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    def on_shape_cutoff(self, instance, value):
+        self._set_shape(
+            shape_image=self.shape_image, mode=self.shape_mode,
+            cutoff=value, color_key=self.shape_color_key
+        )
+
+    def _get_shaped(self):
+        return self._is_shaped()
+
+    shaped = AliasProperty(_get_shaped, None)
+    '''Read only property to check if the window is shapable or not (only works
+    for sdl2 window provider).
+
+    .. versionadded:: 1.10.1
+
+    :attr:`shaped` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_shape_mode(self):
+        if not self.shaped:
+            return ''
+
+        i = self._get_shaped_mode()['mode']
+        modes = ('default', 'binalpha', 'reversebinalpha', 'colorkey')
+        return modes[i]
+
+    def _set_shape_mode(self, value):
+        self._set_shaped_mode(value)
+
+    shape_mode = AliasProperty(_get_shape_mode, _set_shape_mode)
+    '''Window mode for shaping (only works for sdl2 window provider).
+
+    - can be RGB only
+       - `default` - does nothing special
+       - `colorkey` - hides a color of the :attr:`shape_color_key`
+    - has to contain alpha channel
+       - `binalpha` - hides an alpha channel of the :attr:`shape_image`
+       - `reversebinalpha` - shows only the alpha of the :attr:`shape_image`
+
+    .. note::
+        Before actually setting the mode make sure the Window has the same
+        size like the :attr:`shape_image`, preferably via Config before
+        the Window is actually created.
+
+        If the :attr:`shape_image` isn't set, the default one will be used
+        and the mode might not take the desired visual effect.
+
+    .. versionadded:: 1.10.1
+
+    :attr:`shape_mode` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    shape_color_key = ColorProperty([1, 1, 1, 1])
+    '''Color key of the shaped window - sets which color will be hidden from
+    the window :attr:`shape_image` (only works for sdl2 window provider).
+
+    .. versionadded:: 1.10.1
+
+    :attr:`shape_color_key` is a :class:`~kivy.properties.ColorProperty`
+    instance and defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+    def on_shape_color_key(self, instance, value):
+        self._set_shape(
+            shape_image=self.shape_image, mode=self.shape_mode,
+            cutoff=self.shape_cutoff, color_key=value
+        )
+
+    def get_gl_backend_name(self):
+        """
+        Returns the gl backend that will or is used with this window.
+        """
+        return cgl_get_backend_name(
+            allowed=self.gl_backends_allowed,
+            ignored=self.gl_backends_ignored)
+
+    def initialize_gl(self):
+        from kivy.core.gl import init_gl
+        init_gl(allowed=self.gl_backends_allowed,
+                ignored=self.gl_backends_ignored)
+
+    def create_window(self, *largs):
+        '''Will create the main window and configure it.
+
+        .. warning::
+            This method is called automatically at runtime. If you call it, it
+            will recreate a RenderContext and Canvas. This means you'll have a
+            new graphics tree, and the old one will be unusable.
+
+            This method exist to permit the creation of a new OpenGL context
+            AFTER closing the first one. (Like using runTouchApp() and
+            stopTouchApp()).
+
+            This method has only been tested in a unittest environment and
+            is not suitable for Applications.
+
+            Again, don't use this method unless you know exactly what you are
+            doing!
+        '''
+        # just to be sure, if the trigger is set, and if this method is
+        # manually called, unset the trigger
+        self.trigger_create_window.cancel()
+
+        # ensure the window creation will not be called twice
+        if platform in ('android', 'ios'):
+            self._unbind_create_window()
+
+        if not self.initialized:
+            self.initialize_gl()
+
+            # create the render context and canvas, only the first time.
+            from kivy.graphics import RenderContext, Canvas
+            self.render_context = RenderContext()
+            self.canvas = Canvas()
+            self.render_context.add(self.canvas)
+
+        else:
+            # if we get initialized more than once, then reload opengl state
+            # after the second time.
+            # XXX check how it's working on embed platform.
+            if platform == 'linux' or Window.__class__.__name__ == 'WindowSDL':
+                # on linux, it's safe for just sending a resize.
+                self.dispatch('on_pre_resize', *self.size)
+
+            else:
+                # on other platform, window are recreated, we need to reload.
+                from kivy.graphics.context import get_context
+                get_context().reload()
+                Clock.schedule_once(lambda x: self.canvas.ask_update(), 0)
+                self.dispatch('on_pre_resize', *self.size)
+
+        # ensure the gl viewport is correct
+        self.update_viewport()
+
+    def on_flip(self):
+        '''Flip between buffers (event)'''
+        self.flip()
+
+    def flip(self):
+        '''Flip between buffers'''
+        pass
+
+    def _update_childsize(self, instance, value):
+        self.update_childsize([instance])
+
+    def add_widget(self, widget, canvas=None):
+        '''Add a widget to a window'''
+        if widget.parent:
+            from kivy.uix.widget import WidgetException
+            raise WidgetException(
+                'Cannot add %r to window, it already has a parent %r' %
+                (widget, widget.parent)
+            )
+
+        widget.parent = self
+        self.children.insert(0, widget)
+        canvas = self.canvas.before if canvas == 'before' else \
+            self.canvas.after if canvas == 'after' else self.canvas
+        canvas.add(widget.canvas)
+        self.update_childsize([widget])
+        widget.bind(
+            pos_hint=self._update_childsize,
+            size_hint=self._update_childsize,
+            size_hint_max=self._update_childsize,
+            size_hint_min=self._update_childsize,
+            size=self._update_childsize,
+            pos=self._update_childsize)
+
+    def remove_widget(self, widget):
+        '''Remove a widget from a window
+        '''
+        if widget not in self.children:
+            return
+        self.children.remove(widget)
+        if widget.canvas in self.canvas.children:
+            self.canvas.remove(widget.canvas)
+        elif widget.canvas in self.canvas.after.children:
+            self.canvas.after.remove(widget.canvas)
+        elif widget.canvas in self.canvas.before.children:
+            self.canvas.before.remove(widget.canvas)
+        widget.parent = None
+        widget.unbind(
+            pos_hint=self._update_childsize,
+            size_hint=self._update_childsize,
+            size_hint_max=self._update_childsize,
+            size_hint_min=self._update_childsize,
+            size=self._update_childsize,
+            pos=self._update_childsize)
+
+    def clear(self):
+        '''Clear the window with the background color'''
+        # XXX FIXME use late binding
+        from kivy.graphics import opengl as gl
+        gl.glClearColor(*self.clearcolor)
+        gl.glClear(
+            gl.GL_COLOR_BUFFER_BIT
+            | gl.GL_DEPTH_BUFFER_BIT
+            | gl.GL_STENCIL_BUFFER_BIT
+        )
+
+    def set_title(self, title):
+        '''Set the window title.
+
+        .. versionadded:: 1.0.5
+        '''
+        self.title = title
+
+    def set_icon(self, filename):
+        '''Set the icon of the window.
+
+        .. versionadded:: 1.0.5
+        '''
+        self.icon = filename
+
+    def to_widget(self, x, y, initial=True, relative=False):
+        return (x, y)
+
+    def to_window(self, x, y, initial=True, relative=False):
+        return (x, y)
+
+    def to_normalized_pos(self, x, y):
+        '''Transforms absolute coordinates to normalized (0-1) coordinates
+        using :attr:`system_size`.
+
+        .. versionadded:: 2.1.0
+        '''
+        x_max = self.system_size[0] - 1.0
+        y_max = self.system_size[1] - 1.0
+        return (
+            x / x_max if x_max > 0 else 0.0,
+            y / y_max if y_max > 0 else 0.0
+        )
+
+    def transform_motion_event_2d(self, me, widget=None):
+        '''Transforms the motion event `me` to this window size and then if
+        `widget` is passed transforms `me` to `widget`'s local coordinates.
+
+        :raises:
+            `AttributeError`: If widget's ancestor is ``None``.
+
+        .. note::
+            Unless it's a specific case, call
+            :meth:`~kivy.input.motionevent.MotionEvent.push` before and
+            :meth:`~kivy.input.motionevent.MotionEvent.pop` after this method's
+            call to preserve previous values of `me`'s attributes.
+
+        .. versionadded:: 2.1.0
+        '''
+        width, height = self._get_effective_size()
+        me.scale_for_screen(
+            width, height,
+            rotation=self.rotation,
+            smode=self.softinput_mode,
+            kheight=self.keyboard_height
+        )
+        if widget is not None:
+            parent = widget.parent
+            try:
+                if parent:
+                    me.apply_transform_2d(parent.to_widget)
+                else:
+                    me.apply_transform_2d(widget.to_widget)
+                    me.apply_transform_2d(widget.to_parent)
+            except AttributeError:
+                # when using inner window, an app have grab the touch
+                # but app is removed. The touch can't access
+                # to one of the parent. (i.e, self.parent will be None)
+                # and BAM the bug happen.
+                raise
+
+    def _apply_transform(self, m):
+        return m
+
+    def get_window_matrix(self, x=0, y=0):
+        m = Matrix()
+        m.translate(x, y, 0)
+        return m
+
+    def get_root_window(self):
+        return self
+
+    def get_parent_window(self):
+        return self
+
+    def get_parent_layout(self):
+        return None
+
+    def on_draw(self):
+        self.clear()
+        self.render_context.draw()
+
+    def on_motion(self, etype, me):
+        '''Event called when a motion event is received.
+
+        :Parameters:
+            `etype`: str
+                One of "begin", "update" or "end".
+            `me`: :class:`~kivy.input.motionevent.MotionEvent`
+                The motion event currently dispatched.
+
+        .. versionchanged:: 2.1.0
+            Event managers get to handle the touch event first and if none of
+            them accepts the event (by returning `True`) then window will
+            dispatch `me` through "on_touch_down", "on_touch_move",
+            "on_touch_up" events depending on the `etype`. All non-touch events
+            will go only through managers.
+        '''
+        accepted = False
+        for manager in self.event_managers_dict[me.type_id][:]:
+            accepted = manager.dispatch(etype, me) or accepted
+        if accepted:
+            if me.is_touch and etype == 'end':
+                FocusBehavior._handle_post_on_touch_up(me)
+            return accepted
+        if me.is_touch:
+            # TODO: Use me.push/me.pop methods because `me` is transformed
+            # Clock execution of partial ScrollView._on_touch_up method and
+            # other similar cases should be changed so that me.push/me.pop can
+            # be used restore previous values of event's attributes
+            # me.push()
+            self.transform_motion_event_2d(me)
+            if etype == 'begin':
+                self.dispatch('on_touch_down', me)
+            elif etype == 'update':
+                self.dispatch('on_touch_move', me)
+            elif etype == 'end':
+                self.dispatch('on_touch_up', me)
+                FocusBehavior._handle_post_on_touch_up(me)
+            # me.pop()
+
+    def on_touch_down(self, touch):
+        '''Event called when a touch down event is initiated.
+
+        .. versionchanged:: 1.9.0
+            The touch `pos` is now transformed to window coordinates before
+            this method is called. Before, the touch `pos` coordinate would be
+            `(0, 0)` when this method was called.
+        '''
+        for w in self.children[:]:
+            if w.dispatch('on_touch_down', touch):
+                return True
+
+    def on_touch_move(self, touch):
+        '''Event called when a touch event moves (changes location).
+
+        .. versionchanged:: 1.9.0
+            The touch `pos` is now transformed to window coordinates before
+            this method is called. Before, the touch `pos` coordinate would be
+            `(0, 0)` when this method was called.
+        '''
+        for w in self.children[:]:
+            if w.dispatch('on_touch_move', touch):
+                return True
+
+    def on_touch_up(self, touch):
+        '''Event called when a touch event is released (terminated).
+
+        .. versionchanged:: 1.9.0
+            The touch `pos` is now transformed to window coordinates before
+            this method is called. Before, the touch `pos` coordinate would be
+            `(0, 0)` when this method was called.
+        '''
+        for w in self.children[:]:
+            if w.dispatch('on_touch_up', touch):
+                return True
+
+    def on_pre_resize(self, width, height):
+        key = (width, height)
+        if hasattr(self, '_last_resize') and self._last_resize == key:
+            return
+        self._last_resize = key
+        self.dispatch('on_resize', width, height)
+
+    def on_resize(self, width, height):
+        '''Event called when the window is resized.'''
+        self.update_viewport()
+
+    def on_move(self):
+        self.property('top').dispatch(self)
+        self.property('left').dispatch(self)
+
+    def update_viewport(self):
+        from kivy.graphics.opengl import glViewport
+        from kivy.graphics.transformation import Matrix
+        from math import radians
+
+        w, h = self._get_effective_size()
+
+        smode = self.softinput_mode
+        target = self._system_keyboard.target
+        targettop = max(0, target.to_window(0, target.y)[1]) if target else 0
+        kheight = self._kheight
+
+        w2, h2 = w / 2., h / 2.
+        r = radians(self.rotation)
+
+        y = 0
+        _h = h
+        if smode == 'pan':
+            y = kheight
+        elif smode == 'below_target':
+            y = 0 if kheight < targettop else (kheight - targettop)
+        if smode == 'scale':
+            _h -= kheight
+
+        # prepare the viewport
+        glViewport(0, 0, w, _h)
+
+        # do projection matrix
+        projection_mat = Matrix()
+        projection_mat.view_clip(0.0, w, 0.0, h, -1.0, 1.0, 0)
+        self.render_context['projection_mat'] = projection_mat
+
+        # do modelview matrix
+        modelview_mat = Matrix().translate(w2, h2, 0)
+        modelview_mat = modelview_mat.multiply(Matrix().rotate(r, 0, 0, 1))
+
+        w, h = self.size
+        w2, h2 = w / 2., h / 2. - y
+        modelview_mat = modelview_mat.multiply(Matrix().translate(-w2, -h2, 0))
+        self.render_context['modelview_mat'] = modelview_mat
+        frag_modelview_mat = Matrix()
+        frag_modelview_mat.set(flat=modelview_mat.get())
+        self.render_context['frag_modelview_mat'] = frag_modelview_mat
+
+        # redraw canvas
+        self.canvas.ask_update()
+
+        # and update childs
+        self.update_childsize()
+
+    def update_childsize(self, childs=None):
+        width, height = self.size
+        if childs is None:
+            childs = self.children
+        for w in childs:
+            shw, shh = w.size_hint
+            shw_min, shh_min = w.size_hint_min
+            shw_max, shh_max = w.size_hint_max
+
+            if shw is not None and shh is not None:
+                c_w = shw * width
+                c_h = shh * height
+
+                if shw_min is not None and c_w < shw_min:
+                    c_w = shw_min
+                elif shw_max is not None and c_w > shw_max:
+                    c_w = shw_max
+
+                if shh_min is not None and c_h < shh_min:
+                    c_h = shh_min
+                elif shh_max is not None and c_h > shh_max:
+                    c_h = shh_max
+                w.size = c_w, c_h
+            elif shw is not None:
+                c_w = shw * width
+
+                if shw_min is not None and c_w < shw_min:
+                    c_w = shw_min
+                elif shw_max is not None and c_w > shw_max:
+                    c_w = shw_max
+                w.width = c_w
+            elif shh is not None:
+                c_h = shh * height
+
+                if shh_min is not None and c_h < shh_min:
+                    c_h = shh_min
+                elif shh_max is not None and c_h > shh_max:
+                    c_h = shh_max
+                w.height = c_h
+
+            for key, value in w.pos_hint.items():
+                if key == 'x':
+                    w.x = value * width
+                elif key == 'right':
+                    w.right = value * width
+                elif key == 'y':
+                    w.y = value * height
+                elif key == 'top':
+                    w.top = value * height
+                elif key == 'center_x':
+                    w.center_x = value * width
+                elif key == 'center_y':
+                    w.center_y = value * height
+
+    def screenshot(self, name='screenshot{:04d}.png'):
+        '''Save the actual displayed image to a file.
+        '''
+        i = 0
+        path = None
+        if name != 'screenshot{:04d}.png':
+            _ext = name.split('.')[-1]
+            name = ''.join((name[:-(len(_ext) + 1)], '{:04d}.', _ext))
+        while True:
+            i += 1
+            path = join(getcwd(), name.format(i))
+            if not exists(path):
+                break
+        return path
+
+    def on_rotate(self, rotation):
+        '''Event called when the screen has been rotated.
+        '''
+        pass
+
+    def on_close(self, *largs):
+        '''Event called when the window is closed.'''
+        Modules.unregister_window(self)
+        EventLoop.remove_event_listener(self)
+
+    def on_minimize(self, *largs):
+        '''Event called when the window is minimized.
+
+        .. versionadded:: 1.10.0
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def on_maximize(self, *largs):
+        '''Event called when the window is maximized.
+
+        .. versionadded:: 1.10.0
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def on_restore(self, *largs):
+        '''Event called when the window is restored.
+
+        .. versionadded:: 1.10.0
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def on_hide(self, *largs):
+        '''Event called when the window is hidden.
+
+        .. versionadded:: 1.10.0
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def on_show(self, *largs):
+        '''Event called when the window is shown.
+
+        .. versionadded:: 1.10.0
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def on_request_close(self, *largs, **kwargs):
+        '''Event called before we close the window. If a bound function returns
+        `True`, the window will not be closed. If the the event is triggered
+        because of the keyboard escape key, the keyword argument `source` is
+        dispatched along with a value of `keyboard` to the bound functions.
+
+        .. warning::
+            When the bound function returns True the window will not be closed,
+            so use with care because the user would not be able to close the
+            program, even if the red X is clicked.
+        '''
+        pass
+
+    def on_cursor_enter(self, *largs):
+        '''Event called when the cursor enters the window.
+
+        .. versionadded:: 1.9.1
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def on_cursor_leave(self, *largs):
+        '''Event called when the cursor leaves the window.
+
+        .. versionadded:: 1.9.1
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def on_mouse_down(self, x, y, button, modifiers):
+        '''Event called when the mouse is used (pressed/released).'''
+        pass
+
+    def on_mouse_move(self, x, y, modifiers):
+        '''Event called when the mouse is moved with buttons pressed.'''
+        pass
+
+    def on_mouse_up(self, x, y, button, modifiers):
+        '''Event called when the mouse is moved with buttons pressed.'''
+        pass
+
+    def on_joy_axis(self, stickid, axisid, value):
+        '''Event called when a joystick has a stick or other axis moved.
+
+        .. versionadded:: 1.9.0'''
+        pass
+
+    def on_joy_hat(self, stickid, hatid, value):
+        '''Event called when a joystick has a hat/dpad moved.
+
+        .. versionadded:: 1.9.0'''
+        pass
+
+    def on_joy_ball(self, stickid, ballid, xvalue, yvalue):
+        '''Event called when a joystick has a ball moved.
+
+        .. versionadded:: 1.9.0'''
+        pass
+
+    def on_joy_button_down(self, stickid, buttonid):
+        '''Event called when a joystick has a button pressed.
+
+        .. versionadded:: 1.9.0'''
+        pass
+
+    def on_joy_button_up(self, stickid, buttonid):
+        '''Event called when a joystick has a button released.
+
+        .. versionadded:: 1.9.0'''
+        pass
+
+    def on_keyboard(self, key, scancode=None, codepoint=None,
+                    modifier=None, **kwargs):
+        '''Event called when keyboard is used.
+
+        .. warning::
+            Some providers may omit `scancode`, `codepoint` and/or `modifier`.
+        '''
+        if 'unicode' in kwargs:
+            Logger.warning("The use of the unicode parameter is deprecated, "
+                           "and will be removed in future versions. Use "
+                           "codepoint instead, which has identical "
+                           "semantics.")
+
+        # Quit if user presses ESC or the typical OSX shortcuts CMD+q or CMD+w
+        # TODO If just CMD+w is pressed, only the window should be closed.
+        is_osx = platform == 'darwin'
+        if WindowBase.on_keyboard.exit_on_escape:
+            if key == 27 or all([is_osx, key in [113, 119], modifier == 1024]):
+                if not self.dispatch('on_request_close', source='keyboard'):
+                    stopTouchApp()
+                    self.close()
+                    return True
+
+    if Config:
+        on_keyboard.exit_on_escape = Config.getboolean(
+                                        'kivy', 'exit_on_escape')
+
+        def __exit(section, name, value):
+            WindowBase.__dict__['on_keyboard'].exit_on_escape = \
+                Config.getboolean('kivy', 'exit_on_escape')
+
+        Config.add_callback(__exit, 'kivy', 'exit_on_escape')
+
+    def on_key_down(self, key, scancode=None, codepoint=None,
+                    modifier=None, **kwargs):
+        '''Event called when a key is down (same arguments as on_keyboard)'''
+        if 'unicode' in kwargs:
+            Logger.warning("The use of the unicode parameter is deprecated, "
+                           "and will be removed in future versions. Use "
+                           "codepoint instead, which has identical "
+                           "semantics.")
+
+    def on_key_up(self, key, scancode=None, codepoint=None,
+                  modifier=None, **kwargs):
+        '''Event called when a key is released (same arguments as on_keyboard).
+        '''
+        if 'unicode' in kwargs:
+            Logger.warning("The use of the unicode parameter is deprecated, "
+                           "and will be removed in future versions. Use "
+                           "codepoint instead, which has identical "
+                           "semantics.")
+
+    def on_textinput(self, text):
+        '''Event called when text: i.e. alpha numeric non control keys or set
+        of keys is entered. As it is not guaranteed whether we get one
+        character or multiple ones, this event supports handling multiple
+        characters.
+
+        .. versionadded:: 1.9.0
+        '''
+        pass
+
+    def on_drop_begin(self, x, y, *args):
+        '''Event called when a text or a file drop on the application is about
+        to begin. It will be followed-up by a single or a multiple
+        `on_drop_text` or `on_drop_file` events ending with an `on_drop_end`
+        event.
+
+        Arguments `x` and `y` are the mouse cursor position at the time of the
+        drop and you should only rely on them if the drop originated from the
+        mouse.
+
+        :Parameters:
+            `x`: `int`
+                Cursor x position, relative to the window :attr:`left`, at the
+                time of the drop.
+            `y`: `int`
+                Cursor y position, relative to the window :attr:`top`, at the
+                time of the drop.
+            `*args`: `tuple`
+                Additional arugments.
+
+        .. note::
+            This event works with sdl2 window provider.
+
+        .. versionadded:: 2.1.0
+        '''
+        pass
+
+    def on_drop_file(self, filename, x, y, *args):
+        '''Event called when a file is dropped on the application.
+
+        Arguments `x` and `y` are the mouse cursor position at the time of the
+        drop and you should only rely on them if the drop originated from the
+        mouse.
+
+        :Parameters:
+            `filename`: `bytes`
+                Absolute path to a dropped file.
+            `x`: `int`
+                Cursor x position, relative to the window :attr:`left`, at the
+                time of the drop.
+            `y`: `int`
+                Cursor y position, relative to the window :attr:`top`, at the
+                time of the drop.
+            `*args`: `tuple`
+                Additional arugments.
+
+        .. warning::
+            This event currently works with sdl2 window provider, on pygame
+            window provider and OS X with a patched version of pygame.
+            This event is left in place for further evolution
+            (ios, android etc.)
+
+        .. note::
+            On Windows it is possible to drop a file on the window title bar
+            or on its edges and for that case :attr:`mouse_pos` won't be
+            updated as the mouse cursor is not within the window.
+
+        .. note::
+            This event doesn't work for apps with elevated permissions,
+            because the OS API calls are filtered. Check issue
+            `#4999 <https://github.com/kivy/kivy/issues/4999>`_ for
+            pointers to workarounds.
+
+        .. versionadded:: 1.2.0
+
+        .. versionchanged:: 2.1.0
+            Renamed from `on_dropfile` to `on_drop_file`.
+        '''
+        pass
+
+    @deprecated(msg='Deprecated in 2.1.0, use on_drop_file event instead. '
+                    'Event on_dropfile will be removed in the next two '
+                    'releases.')
+    def on_dropfile(self, filename):
+        pass
+
+    def on_drop_text(self, text, x, y, *args):
+        '''Event called when a text is dropped on the application.
+
+        Arguments `x` and `y` are the mouse cursor position at the time of the
+        drop and you should only rely on them if the drop originated from the
+        mouse.
+
+        :Parameters:
+            `text`: `bytes`
+                Text which is dropped.
+            `x`: `int`
+                Cursor x position, relative to the window :attr:`left`, at the
+                time of the drop.
+            `y`: `int`
+                Cursor y position, relative to the window :attr:`top`, at the
+                time of the drop.
+            `*args`: `tuple`
+                Additional arugments.
+
+        .. note::
+            This event works with sdl2 window provider on x11 window.
+
+        .. note::
+            On Windows it is possible to drop a text on the window title bar
+            or on its edges and for that case :attr:`mouse_pos` won't be
+            updated as the mouse cursor is not within the window.
+
+        .. versionadded:: 2.1.0
+        '''
+        pass
+
+    def on_drop_end(self, x, y, *args):
+        '''Event called when a text or a file drop on the application has
+        ended.
+
+        Arguments `x` and `y` are the mouse cursor position at the time of the
+        drop and you should only rely on them if the drop originated from the
+        mouse.
+
+        :Parameters:
+            `x`: `int`
+                Cursor x position, relative to the window :attr:`left`, at the
+                time of the drop.
+            `y`: `int`
+                Cursor y position, relative to the window :attr:`top`, at the
+                time of the drop.
+            `*args`: `tuple`
+                Additional arugments.
+
+        .. note::
+            This event works with sdl2 window provider.
+
+        .. versionadded:: 2.1.0
+        '''
+        pass
+
+    def on_memorywarning(self):
+        '''Event called when the platform have memory issue.
+        Your goal is to clear the cache in your app as much as you can,
+        release unused widgets, do garbage collection etc.
+
+        Currently, this event is fired only from the SDL2 provider, for
+        iOS and Android.
+
+        .. versionadded:: 1.9.0
+        '''
+        pass
+
+    def on_textedit(self, text):
+        '''Event called when inputting with IME.
+        The string inputting with IME is set as the parameter of
+        this event.
+
+        .. versionadded:: 1.10.1
+        '''
+        pass
+
+    dpi = NumericProperty(96.)
+    '''Return the DPI of the screen as computed by the window. If the
+    implementation doesn't support DPI lookup, it's 96.
+
+    .. warning::
+
+        This value is not cross-platform. Use
+        :attr:`kivy.metrics.Metrics.dpi` instead.
+    '''
+
+    def configure_keyboards(self):
+        # Configure how to provide keyboards (virtual or not)
+
+        # register system keyboard to listening keys from window
+        sk = self._system_keyboard
+        self.bind(
+            on_key_down=sk._on_window_key_down,
+            on_key_up=sk._on_window_key_up,
+            on_textinput=sk._on_window_textinput)
+
+        # use the device's real keyboard
+        self.use_syskeyboard = True
+
+        # use the device's real keyboard
+        self.allow_vkeyboard = False
+
+        # one single vkeyboard shared between all widgets
+        self.single_vkeyboard = True
+
+        # the single vkeyboard is always sitting at the same position
+        self.docked_vkeyboard = False
+
+        # now read the configuration
+        mode = Config.get('kivy', 'keyboard_mode')
+        if mode not in ('', 'system', 'dock', 'multi', 'systemanddock',
+                        'systemandmulti'):
+            Logger.critical('Window: unknown keyboard mode %r' % mode)
+
+        # adapt mode according to the configuration
+        if mode == 'system':
+            self.use_syskeyboard = True
+            self.allow_vkeyboard = False
+            self.single_vkeyboard = True
+            self.docked_vkeyboard = False
+        elif mode == 'dock':
+            self.use_syskeyboard = False
+            self.allow_vkeyboard = True
+            self.single_vkeyboard = True
+            self.docked_vkeyboard = True
+        elif mode == 'multi':
+            self.use_syskeyboard = False
+            self.allow_vkeyboard = True
+            self.single_vkeyboard = False
+            self.docked_vkeyboard = False
+        elif mode == 'systemanddock':
+            self.use_syskeyboard = True
+            self.allow_vkeyboard = True
+            self.single_vkeyboard = True
+            self.docked_vkeyboard = True
+        elif mode == 'systemandmulti':
+            self.use_syskeyboard = True
+            self.allow_vkeyboard = True
+            self.single_vkeyboard = False
+            self.docked_vkeyboard = False
+
+        Logger.info(
+            'Window: virtual keyboard %sallowed, %s, %s' % (
+                '' if self.allow_vkeyboard else 'not ',
+                'single mode' if self.single_vkeyboard else 'multiuser mode',
+                'docked' if self.docked_vkeyboard else 'not docked'))
+
+    def set_vkeyboard_class(self, cls):
+        '''.. versionadded:: 1.0.8
+
+        Set the VKeyboard class to use. If set to `None`, it will use the
+        :class:`kivy.uix.vkeyboard.VKeyboard`.
+        '''
+        self._vkeyboard_cls = cls
+
+    def release_all_keyboards(self):
+        '''.. versionadded:: 1.0.8
+
+        This will ensure that no virtual keyboard / system keyboard is
+        requested. All instances will be closed.
+        '''
+        for key in list(self._keyboards.keys())[:]:
+            keyboard = self._keyboards[key]
+            if keyboard:
+                keyboard.release()
+
+    def request_keyboard(
+            self, callback, target, input_type='text', keyboard_suggestions=True
+    ):
+        '''.. versionadded:: 1.0.4
+
+        Internal widget method to request the keyboard. This method is rarely
+        required by the end-user as it is handled automatically by the
+        :class:`~kivy.uix.textinput.TextInput`. We expose it in case you want
+        to handle the keyboard manually for unique input scenarios.
+
+        A widget can request the keyboard, indicating a callback to call
+        when the keyboard is released (or taken by another widget).
+
+        :Parameters:
+            `callback`: func
+                Callback that will be called when the keyboard is
+                closed. This can be because somebody else requested the
+                keyboard or the user closed it.
+            `target`: Widget
+                Attach the keyboard to the specified `target`. This should be
+                the widget that requested the keyboard. Ensure you have a
+                different target attached to each keyboard if you're working in
+                a multi user mode.
+
+                .. versionadded:: 1.0.8
+
+            `input_type`: string
+                Choose the type of soft keyboard to request. Can be one of
+                'null', 'text', 'number', 'url', 'mail', 'datetime', 'tel',
+                'address'.
+
+                .. note::
+
+                    `input_type` is currently only honored on Android.
+
+                .. versionadded:: 1.8.0
+
+                .. versionchanged:: 2.1.0
+                    Added `null` to soft keyboard types.
+
+            `keyboard_suggestions`: bool
+                If True provides auto suggestions on top of keyboard.
+                This will only work if input_type is set to `text`, `url`,
+                `mail` or `address`.
+
+                .. versionadded:: 2.1.0
+
+        :Return:
+            An instance of :class:`Keyboard` containing the callback, target,
+            and if the configuration allows it, a
+            :class:`~kivy.uix.vkeyboard.VKeyboard` instance attached as a
+            *.widget* property.
+
+        .. note::
+
+            The behavior of this function is heavily influenced by the current
+            `keyboard_mode`. Please see the Config's
+            :ref:`configuration tokens <configuration-tokens>` section for
+            more information.
+
+        '''
+
+        # release any previous keyboard attached.
+        self.release_keyboard(target)
+
+        # if we can use virtual vkeyboard, activate it.
+        if self.allow_vkeyboard:
+            keyboard = None
+
+            # late import
+            global VKeyboard
+            if VKeyboard is None and self._vkeyboard_cls is None:
+                from kivy.uix.vkeyboard import VKeyboard
+                self._vkeyboard_cls = VKeyboard
+
+            # if the keyboard doesn't exist, create it.
+            key = 'single' if self.single_vkeyboard else target
+            if key not in self._keyboards:
+                vkeyboard = self._vkeyboard_cls()
+                keyboard = Keyboard(widget=vkeyboard, window=self)
+                vkeyboard.bind(
+                    on_key_down=keyboard._on_vkeyboard_key_down,
+                    on_key_up=keyboard._on_vkeyboard_key_up,
+                    on_textinput=keyboard._on_vkeyboard_textinput)
+                self._keyboards[key] = keyboard
+            else:
+                keyboard = self._keyboards[key]
+
+            # configure vkeyboard
+            keyboard.target = keyboard.widget.target = target
+            keyboard.callback = keyboard.widget.callback = callback
+
+            # add to the window
+            self.add_widget(keyboard.widget)
+
+            # only after add, do dock mode
+            keyboard.widget.docked = self.docked_vkeyboard
+            keyboard.widget.setup_mode()
+
+            # sets vkeyboard position according to Window.softinput_mode
+            if self.softinput_mode == 'pan':
+                keyboard.widget.top = 0
+            elif self.softinput_mode == 'below_target':
+                keyboard.widget.top = keyboard.target.y
+
+        else:
+            # system keyboard, just register the callback.
+            keyboard = self._system_keyboard
+            keyboard.callback = callback
+            keyboard.target = target
+
+        # use system (hardware) keyboard according to flag
+        if self.allow_vkeyboard and self.use_syskeyboard:
+            self.unbind(
+                on_key_down=keyboard._on_window_key_down,
+                on_key_up=keyboard._on_window_key_up,
+                on_textinput=keyboard._on_window_textinput)
+            self.bind(
+                on_key_down=keyboard._on_window_key_down,
+                on_key_up=keyboard._on_window_key_up,
+                on_textinput=keyboard._on_window_textinput)
+
+        return keyboard
+
+    def release_keyboard(self, target=None):
+        '''.. versionadded:: 1.0.4
+
+        Internal method for the widget to release the real-keyboard. Check
+        :meth:`request_keyboard` to understand how it works.
+        '''
+        if self.allow_vkeyboard:
+            key = 'single' if self.single_vkeyboard else target
+            if key not in self._keyboards:
+                return
+            keyboard = self._keyboards[key]
+            callback = keyboard.callback
+            if callback:
+                keyboard.callback = None
+                callback()
+            keyboard.target = None
+            self.remove_widget(keyboard.widget)
+            if key != 'single' and key in self._keyboards:
+                del self._keyboards[key]
+        elif self._system_keyboard.callback:
+            # this way will prevent possible recursion.
+            callback = self._system_keyboard.callback
+            self._system_keyboard.callback = None
+            callback()
+            return True
+
+    def grab_mouse(self):
+        '''Grab mouse - so won't leave window
+
+        .. versionadded:: 1.10.0
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+    def ungrab_mouse(self):
+        '''Ungrab mouse
+
+        .. versionadded:: 1.10.0
+
+        .. note::
+            This feature requires the SDL2 window provider.
+        '''
+        pass
+
+
+#: Instance of a :class:`WindowBase` implementation
+window_impl = []
+if platform == 'linux' and (pi_version or 4) < 4:
+    window_impl += [('egl_rpi', 'window_egl_rpi', 'WindowEglRpi')]
+if USE_SDL2:
+    window_impl += [('sdl2', 'window_sdl2', 'WindowSDL')]
+else:
+    window_impl += [
+        ('pygame', 'window_pygame', 'WindowPygame')]
+if platform == 'linux':
+    window_impl += [('x11', 'window_x11', 'WindowX11')]
+Window = core_select_lib('window', window_impl, True)
diff --git a/kivy/core/window/__pycache__/__init__.cpython-310.pyc b/kivy/core/window/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..26733e7
Binary files /dev/null and b/kivy/core/window/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/core/window/__pycache__/window_egl_rpi.cpython-310.pyc b/kivy/core/window/__pycache__/window_egl_rpi.cpython-310.pyc
new file mode 100644
index 0000000..6b8744f
Binary files /dev/null and b/kivy/core/window/__pycache__/window_egl_rpi.cpython-310.pyc differ
diff --git a/kivy/core/window/__pycache__/window_pygame.cpython-310.pyc b/kivy/core/window/__pycache__/window_pygame.cpython-310.pyc
new file mode 100644
index 0000000..2bf0ae4
Binary files /dev/null and b/kivy/core/window/__pycache__/window_pygame.cpython-310.pyc differ
diff --git a/kivy/core/window/__pycache__/window_sdl2.cpython-310.pyc b/kivy/core/window/__pycache__/window_sdl2.cpython-310.pyc
new file mode 100644
index 0000000..75f441f
Binary files /dev/null and b/kivy/core/window/__pycache__/window_sdl2.cpython-310.pyc differ
diff --git a/kivy/core/window/_window_sdl2.cpython-310-x86_64-linux-gnu.so b/kivy/core/window/_window_sdl2.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..ee2869c
Binary files /dev/null and b/kivy/core/window/_window_sdl2.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/core/window/window_attrs.pxi b/kivy/core/window/window_attrs.pxi
new file mode 100644
index 0000000..6dc4daa
--- /dev/null
+++ b/kivy/core/window/window_attrs.pxi
@@ -0,0 +1,30 @@
+include "../../include/config.pxi"
+
+IF USE_WAYLAND:
+    cdef extern from "wayland-client-protocol.h":
+        cdef struct wl_display:
+            pass
+
+        cdef struct wl_surface:
+            pass
+
+        cdef struct wl_shell_surface:
+            pass
+
+IF USE_X11:
+    cdef extern from "X11/Xlib.h":
+        cdef struct _XDisplay:
+            pass
+
+        ctypedef _XDisplay Display
+
+        ctypedef int XID
+        ctypedef XID Window
+
+IF UNAME_SYSNAME == 'Windows':
+    cdef extern from "windows.h":
+        ctypedef void *HANDLE
+
+        ctypedef HANDLE HWND
+        ctypedef HANDLE HDC
+        ctypedef HANDLE HINSTANCE
diff --git a/kivy/core/window/window_egl_rpi.py b/kivy/core/window/window_egl_rpi.py
new file mode 100644
index 0000000..0cc2deb
--- /dev/null
+++ b/kivy/core/window/window_egl_rpi.py
@@ -0,0 +1,86 @@
+'''
+EGL Rpi Window: EGL Window provider, specialized for the Pi
+
+Inspired by: rpi_vid_core + JF002 rpi kivy  repo
+'''
+
+__all__ = ('WindowEglRpi', )
+
+from kivy.logger import Logger
+from kivy.core.window import WindowBase
+from kivy.base import EventLoop, ExceptionManager, stopTouchApp
+from kivy.lib.vidcore_lite import bcm, egl
+from os import environ
+
+# Default display IDs.
+(DISPMANX_ID_MAIN_LCD,
+ DISPMANX_ID_AUX_LCD,
+ DISPMANX_ID_HDMI,
+ DISPMANX_ID_SDTV,
+ DISPMANX_ID_FORCE_LCD,
+ DISPMANX_ID_FORCE_TV,
+ DISPMANX_ID_FORCE_OTHER) = range(7)
+
+
+class WindowEglRpi(WindowBase):
+
+    _rpi_dispmanx_id = int(environ.get("KIVY_BCM_DISPMANX_ID", "0"))
+    _rpi_dispmanx_layer = int(environ.get("KIVY_BCM_DISPMANX_LAYER", "0"))
+
+    gl_backends_ignored = ['sdl2']
+
+    def create_window(self):
+        bcm.host_init()
+
+        w, h = bcm.graphics_get_display_size(self._rpi_dispmanx_id)
+        Logger.debug('Window: Actual display size: {}x{}'.format(
+            w, h))
+        self._size = w, h
+        self._create_window(w, h)
+        self._create_egl_context(self.win, 0)
+        super(WindowEglRpi, self).create_window()
+
+    def _create_window(self, w, h):
+        dst = bcm.Rect(0, 0, w, h)
+        src = bcm.Rect(0, 0, w << 16, h << 16)
+        display = egl.bcm_display_open(self._rpi_dispmanx_id)
+        update = egl.bcm_update_start(0)
+        element = egl.bcm_element_add(
+            update, display, self._rpi_dispmanx_layer, dst, src)
+        self.win = egl.NativeWindow(element, w, h)
+        egl.bcm_update_submit_sync(update)
+
+    def _create_egl_context(self, win, flags):
+        api = egl._constants.EGL_OPENGL_ES_API
+        c = egl._constants
+
+        attribs = [
+            c.EGL_RED_SIZE, 8,
+            c.EGL_GREEN_SIZE, 8,
+            c.EGL_BLUE_SIZE, 8,
+            c.EGL_ALPHA_SIZE, 8,
+            c.EGL_DEPTH_SIZE, 16,
+            c.EGL_STENCIL_SIZE, 8,
+            c.EGL_SURFACE_TYPE, c.EGL_WINDOW_BIT,
+            c.EGL_NONE]
+
+        attribs_context = [c.EGL_CONTEXT_CLIENT_VERSION, 2, c.EGL_NONE]
+
+        display = egl.GetDisplay(c.EGL_DEFAULT_DISPLAY)
+        egl.Initialise(display)
+        egl.BindAPI(c.EGL_OPENGL_ES_API)
+        egl.GetConfigs(display)
+        config = egl.ChooseConfig(display, attribs, 1)[0]
+        surface = egl.CreateWindowSurface(display, config, win)
+        context = egl.CreateContext(display, config, None, attribs_context)
+        egl.MakeCurrent(display, surface, surface, context)
+
+        self.egl_info = (display, surface, context)
+        egl.MakeCurrent(display, surface, surface, context)
+
+    def close(self):
+        egl.Terminate(self.egl_info[0])
+
+    def flip(self):
+        if not EventLoop.quit:
+            egl.SwapBuffers(self.egl_info[0], self.egl_info[1])
diff --git a/kivy/core/window/window_info.cpython-310-x86_64-linux-gnu.so b/kivy/core/window/window_info.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..5230f05
Binary files /dev/null and b/kivy/core/window/window_info.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/core/window/window_info.pxd b/kivy/core/window/window_info.pxd
new file mode 100644
index 0000000..0fb8ff9
--- /dev/null
+++ b/kivy/core/window/window_info.pxd
@@ -0,0 +1,19 @@
+include "window_attrs.pxi"
+
+from libc.stdint cimport uintptr_t
+
+IF USE_WAYLAND:
+    cdef class WindowInfoWayland:
+        cdef wl_display *display
+        cdef wl_surface *surface
+        cdef wl_shell_surface *shell_surface
+
+IF USE_X11:
+    cdef class WindowInfoX11:
+        cdef Display *display
+        cdef Window window
+
+IF UNAME_SYSNAME == 'Windows':
+    cdef class WindowInfoWindows:
+        cdef HWND window
+        cdef HDC hdc
diff --git a/kivy/core/window/window_pygame.py b/kivy/core/window/window_pygame.py
new file mode 100644
index 0000000..2ee5f80
--- /dev/null
+++ b/kivy/core/window/window_pygame.py
@@ -0,0 +1,449 @@
+'''
+Window Pygame: windowing provider based on Pygame
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('WindowPygame', )
+
+# fail early if possible
+import pygame
+
+from kivy.compat import PY2
+from kivy.core.window import WindowBase
+from kivy.core import CoreCriticalException
+from os import environ
+from os.path import exists, join
+from kivy.config import Config
+from kivy import kivy_data_dir
+from kivy.base import ExceptionManager
+from kivy.logger import Logger
+from kivy.base import stopTouchApp, EventLoop
+from kivy.utils import platform, deprecated
+from kivy.resources import resource_find
+
+try:
+    android = None
+    if platform == 'android':
+        import android
+except ImportError:
+    pass
+
+# late binding
+glReadPixels = GL_RGBA = GL_UNSIGNED_BYTE = None
+
+
+class WindowPygame(WindowBase):
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, *largs, **kwargs):
+        super(WindowPygame, self).__init__(*largs, **kwargs)
+
+    def create_window(self, *largs):
+        # ensure the mouse is still not up after window creation, otherwise, we
+        # have some weird bugs
+        self.dispatch('on_mouse_up', 0, 0, 'all', [])
+
+        # force display to show (available only for fullscreen)
+        displayidx = Config.getint('graphics', 'display')
+        if 'SDL_VIDEO_FULLSCREEN_HEAD' not in environ and displayidx != -1:
+            environ['SDL_VIDEO_FULLSCREEN_HEAD'] = '%d' % displayidx
+
+        # init some opengl, same as before.
+        self.flags = pygame.HWSURFACE | pygame.OPENGL | pygame.DOUBLEBUF
+
+        # right now, activate resizable window only on linux.
+        # on window / macosx, the opengl context is lost, and we need to
+        # reconstruct everything. Check #168 for a state of the work.
+        if platform in ('linux', 'macosx', 'win') and \
+                Config.getboolean('graphics', 'resizable'):
+            self.flags |= pygame.RESIZABLE
+
+        try:
+            pygame.display.init()
+        except pygame.error as e:
+            raise CoreCriticalException(e.message)
+
+        multisamples = Config.getint('graphics', 'multisamples')
+
+        if multisamples > 0:
+            pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 1)
+            pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES,
+                                            multisamples)
+        pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 16)
+        pygame.display.gl_set_attribute(pygame.GL_STENCIL_SIZE, 1)
+        pygame.display.set_caption(self.title)
+
+        if self.position == 'auto':
+            self._pos = None
+        elif self.position == 'custom':
+            self._pos = self.left, self.top
+        else:
+            raise ValueError('position token in configuration accept only '
+                             '"auto" or "custom"')
+
+        if self._fake_fullscreen:
+            if not self.borderless:
+                self.fullscreen = self._fake_fullscreen = False
+            elif not self.fullscreen or self.fullscreen == 'auto':
+                self.borderless = self._fake_fullscreen = False
+
+        if self.fullscreen == 'fake':
+            self.borderless = self._fake_fullscreen = True
+            Logger.warning("The 'fake' fullscreen option has been "
+                            "deprecated, use Window.borderless or the "
+                            "borderless Config option instead.")
+
+        if self.fullscreen == 'fake' or self.borderless:
+            Logger.debug('WinPygame: Set window to borderless mode.')
+
+            self.flags |= pygame.NOFRAME
+            # If no position set in borderless mode, we always need
+            # to set the position. So use 0, 0.
+            if self._pos is None:
+                self._pos = (0, 0)
+            environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos
+
+        elif self.fullscreen in ('auto', True):
+            Logger.debug('WinPygame: Set window to fullscreen mode')
+            self.flags |= pygame.FULLSCREEN
+
+        elif self._pos is not None:
+            environ['SDL_VIDEO_WINDOW_POS'] = '%d,%d' % self._pos
+
+        # never stay with a None pos, application using w.center will be fired.
+        self._pos = (0, 0)
+
+        # prepare keyboard
+        repeat_delay = int(Config.get('kivy', 'keyboard_repeat_delay'))
+        repeat_rate = float(Config.get('kivy', 'keyboard_repeat_rate'))
+        pygame.key.set_repeat(repeat_delay, int(1000. / repeat_rate))
+
+        # set window icon before calling set_mode
+        try:
+            filename_icon = self.icon or Config.get('kivy', 'window_icon')
+            if filename_icon == '':
+                logo_size = 32
+                if platform == 'macosx':
+                    logo_size = 512
+                elif platform == 'win':
+                    logo_size = 64
+                filename_icon = 'kivy-icon-{}.png'.format(logo_size)
+                filename_icon = resource_find(
+                        join(kivy_data_dir, 'logo', filename_icon))
+            self.set_icon(filename_icon)
+        except:
+            Logger.exception('Window: cannot set icon')
+
+        # try to use mode with multisamples
+        try:
+            self._pygame_set_mode()
+        except pygame.error as e:
+            if multisamples:
+                Logger.warning('WinPygame: Video: failed (multisamples=%d)' %
+                               multisamples)
+                Logger.warning('WinPygame: trying without antialiasing')
+                pygame.display.gl_set_attribute(
+                    pygame.GL_MULTISAMPLEBUFFERS, 0)
+                pygame.display.gl_set_attribute(
+                    pygame.GL_MULTISAMPLESAMPLES, 0)
+                multisamples = 0
+                try:
+                    self._pygame_set_mode()
+                except pygame.error as e:
+                    raise CoreCriticalException(e.message)
+            else:
+                raise CoreCriticalException(e.message)
+
+        if pygame.RESIZABLE & self.flags:
+            self._pygame_set_mode()
+
+        info = pygame.display.Info()
+        self._size = (info.current_w, info.current_h)
+        # self.dispatch('on_resize', *self._size)
+
+        # in order to debug futur issue with pygame/display, let's show
+        # more debug output.
+        Logger.debug('Window: Display driver ' + pygame.display.get_driver())
+        Logger.debug('Window: Actual window size: %dx%d',
+                     info.current_w, info.current_h)
+        if platform != 'android':
+            # unsupported platform, such as android that doesn't support
+            # gl_get_attribute.
+            Logger.debug(
+                'Window: Actual color bits r%d g%d b%d a%d',
+                pygame.display.gl_get_attribute(pygame.GL_RED_SIZE),
+                pygame.display.gl_get_attribute(pygame.GL_GREEN_SIZE),
+                pygame.display.gl_get_attribute(pygame.GL_BLUE_SIZE),
+                pygame.display.gl_get_attribute(pygame.GL_ALPHA_SIZE))
+            Logger.debug(
+                'Window: Actual depth bits: %d',
+                pygame.display.gl_get_attribute(pygame.GL_DEPTH_SIZE))
+            Logger.debug(
+                'Window: Actual stencil bits: %d',
+                pygame.display.gl_get_attribute(pygame.GL_STENCIL_SIZE))
+            Logger.debug(
+                'Window: Actual multisampling samples: %d',
+                pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLESAMPLES))
+        super(WindowPygame, self).create_window()
+
+        # set mouse visibility
+        self._set_cursor_state(self.show_cursor)
+
+        # if we are on android platform, automatically create hooks
+        if android:
+            from kivy.support import install_android
+            install_android()
+
+    def close(self):
+        pygame.display.quit()
+        super(WindowPygame, self).close()
+
+    def on_title(self, instance, value):
+        if self.initialized:
+            pygame.display.set_caption(self.title)
+
+    def set_icon(self, filename):
+        if not exists(filename):
+            return False
+        try:
+            if platform == 'win':
+                try:
+                    if self._set_icon_win(filename):
+                        return True
+                except:
+                    # fallback on standard loading then.
+                    pass
+
+            # for all others platform, or if the ico is not available, use the
+            # default way to set it.
+            self._set_icon_standard(filename)
+            super(WindowPygame, self).set_icon(filename)
+        except:
+            Logger.exception('WinPygame: unable to set icon')
+
+    def _set_icon_standard(self, filename):
+        if PY2:
+            try:
+                im = pygame.image.load(filename)
+            except UnicodeEncodeError:
+                im = pygame.image.load(filename.encode('utf8'))
+        else:
+            im = pygame.image.load(filename)
+        if im is None:
+            raise Exception('Unable to load window icon (not found)')
+        pygame.display.set_icon(im)
+
+    def _set_icon_win(self, filename):
+        # ensure the window ico is ended by ico
+        if not filename.endswith('.ico'):
+            filename = '{}.ico'.format(filename.rsplit('.', 1)[0])
+        if not exists(filename):
+            return False
+
+        import win32api
+        import win32gui
+        import win32con
+        hwnd = pygame.display.get_wm_info()['window']
+        icon_big = win32gui.LoadImage(
+            None, filename, win32con.IMAGE_ICON,
+            48, 48, win32con.LR_LOADFROMFILE)
+        icon_small = win32gui.LoadImage(
+            None, filename, win32con.IMAGE_ICON,
+            16, 16, win32con.LR_LOADFROMFILE)
+        win32api.SendMessage(
+            hwnd, win32con.WM_SETICON, win32con.ICON_SMALL, icon_small)
+        win32api.SendMessage(
+            hwnd, win32con.WM_SETICON, win32con.ICON_BIG, icon_big)
+        return True
+
+    def _set_cursor_state(self, value):
+        pygame.mouse.set_visible(value)
+
+    def screenshot(self, *largs, **kwargs):
+        global glReadPixels, GL_RGBA, GL_UNSIGNED_BYTE
+        filename = super(WindowPygame, self).screenshot(*largs, **kwargs)
+        if filename is None:
+            return None
+        if glReadPixels is None:
+            from kivy.graphics.opengl import (glReadPixels, GL_RGBA,
+                                              GL_UNSIGNED_BYTE)
+        width, height = self.system_size
+        data = glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE)
+        data = bytes(bytearray(data))
+        surface = pygame.image.fromstring(data, (width, height), 'RGBA', True)
+        pygame.image.save(surface, filename)
+        Logger.debug('Window: Screenshot saved at <%s>' % filename)
+        return filename
+
+    def flip(self):
+        pygame.display.flip()
+        super(WindowPygame, self).flip()
+
+    @deprecated
+    def toggle_fullscreen(self):
+        if self.flags & pygame.FULLSCREEN:
+            self.flags &= ~pygame.FULLSCREEN
+        else:
+            self.flags |= pygame.FULLSCREEN
+        self._pygame_set_mode()
+
+    def mainloop(self):
+        for event in pygame.event.get():
+
+            # kill application (SIG_TERM)
+            if event.type == pygame.QUIT:
+                if self.dispatch('on_request_close'):
+                    continue
+                EventLoop.quit = True
+                self.close()
+
+            # mouse move
+            elif event.type == pygame.MOUSEMOTION:
+                x, y = event.pos
+                self.mouse_pos = x, self.system_size[1] - y
+                # don't dispatch motion if no button are pressed
+                if event.buttons == (0, 0, 0):
+                    continue
+                self._mouse_x = x
+                self._mouse_y = y
+                self._mouse_meta = self.modifiers
+                self.dispatch('on_mouse_move', x, y, self.modifiers)
+
+            # mouse action
+            elif event.type in (pygame.MOUSEBUTTONDOWN,
+                                pygame.MOUSEBUTTONUP):
+                self._pygame_update_modifiers()
+                x, y = event.pos
+                btn = 'left'
+                if event.button == 3:
+                    btn = 'right'
+                elif event.button == 2:
+                    btn = 'middle'
+                elif event.button == 4:
+                    btn = 'scrolldown'
+                elif event.button == 5:
+                    btn = 'scrollup'
+                elif event.button == 6:
+                    btn = 'scrollright'
+                elif event.button == 7:
+                    btn = 'scrollleft'
+                eventname = 'on_mouse_down'
+                if event.type == pygame.MOUSEBUTTONUP:
+                    eventname = 'on_mouse_up'
+                self._mouse_x = x
+                self._mouse_y = y
+                self._mouse_meta = self.modifiers
+                self._mouse_btn = btn
+                self._mouse_down = eventname == 'on_mouse_down'
+                self.dispatch(eventname, x, y, btn, self.modifiers)
+
+            # joystick action
+            elif event.type == pygame.JOYAXISMOTION:
+                self.dispatch('on_joy_axis', event.joy, event.axis,
+                                event.value)
+
+            elif event.type == pygame.JOYHATMOTION:
+                self.dispatch('on_joy_hat', event.joy, event.hat, event.value)
+
+            elif event.type == pygame.JOYBALLMOTION:
+                self.dispatch('on_joy_ball', event.joy, event.ballid,
+                            event.rel[0], event.rel[1])
+
+            elif event.type == pygame.JOYBUTTONDOWN:
+                self.dispatch('on_joy_button_down', event.joy, event.button)
+
+            elif event.type == pygame.JOYBUTTONUP:
+                self.dispatch('on_joy_button_up', event.joy, event.button)
+
+            # keyboard action
+            elif event.type in (pygame.KEYDOWN, pygame.KEYUP):
+                self._pygame_update_modifiers(event.mod)
+                # atm, don't handle keyup
+                if event.type == pygame.KEYUP:
+                    self.dispatch('on_key_up', event.key,
+                                  event.scancode)
+                    continue
+
+                # don't dispatch more key if down event is accepted
+                if self.dispatch('on_key_down', event.key,
+                                 event.scancode, event.unicode,
+                                 self.modifiers):
+                    continue
+                self.dispatch('on_keyboard', event.key,
+                              event.scancode, event.unicode,
+                              self.modifiers)
+
+            # video resize
+            elif event.type == pygame.VIDEORESIZE:
+                self._size = event.size
+                self.update_viewport()
+
+            elif event.type == pygame.VIDEOEXPOSE:
+                self.canvas.ask_update()
+
+            # ignored event
+            elif event.type == pygame.ACTIVEEVENT:
+                pass
+
+            # drop file (pygame patch needed)
+            elif event.type == pygame.USEREVENT and \
+                    hasattr(pygame, 'USEREVENT_DROPFILE') and \
+                    event.code == pygame.USEREVENT_DROPFILE:
+                drop_x, drop_y = pygame.mouse.get_pos()
+                self.dispatch('on_drop_file', event.filename, drop_x, drop_y)
+
+            '''
+            # unhandled event !
+            else:
+                Logger.debug('WinPygame: Unhandled event %s' % str(event))
+            '''
+        if not pygame.display.get_active():
+            pygame.time.wait(100)
+
+    #
+    # Pygame wrapper
+    #
+    def _pygame_set_mode(self, size=None):
+        if size is None:
+            size = self.size
+        if self.fullscreen == 'auto':
+            pygame.display.set_mode((0, 0), self.flags)
+        else:
+            pygame.display.set_mode(size, self.flags)
+
+    def _pygame_update_modifiers(self, mods=None):
+        # Available mod, from dir(pygame)
+        # 'KMOD_ALT', 'KMOD_CAPS', 'KMOD_CTRL', 'KMOD_LALT',
+        # 'KMOD_LCTRL', 'KMOD_LMETA', 'KMOD_LSHIFT', 'KMOD_META',
+        # 'KMOD_MODE', 'KMOD_NONE'
+        if mods is None:
+            mods = pygame.key.get_mods()
+        self._modifiers = []
+        if mods & (pygame.KMOD_SHIFT | pygame.KMOD_LSHIFT):
+            self._modifiers.append('shift')
+        if mods & (pygame.KMOD_ALT | pygame.KMOD_LALT):
+            self._modifiers.append('alt')
+        if mods & (pygame.KMOD_CTRL | pygame.KMOD_LCTRL):
+            self._modifiers.append('ctrl')
+        if mods & (pygame.KMOD_META | pygame.KMOD_LMETA):
+            self._modifiers.append('meta')
+
+    def request_keyboard(
+            self, callback, target, input_type='text', keyboard_suggestions=True
+    ):
+        keyboard = super(WindowPygame, self).request_keyboard(
+            callback, target, input_type, keyboard_suggestions)
+        if android and not self.allow_vkeyboard:
+            android.show_keyboard(target, input_type)
+        return keyboard
+
+    def release_keyboard(self, *largs):
+        super(WindowPygame, self).release_keyboard(*largs)
+        if android:
+            android.hide_keyboard()
+        return True
diff --git a/kivy/core/window/window_sdl2.py b/kivy/core/window/window_sdl2.py
new file mode 100644
index 0000000..76d60a1
--- /dev/null
+++ b/kivy/core/window/window_sdl2.py
@@ -0,0 +1,986 @@
+# found a way to include it more easily.
+'''
+SDL2 Window
+===========
+
+Windowing provider directly based on our own wrapped version of SDL.
+
+TODO:
+    - fix keys
+    - support scrolling
+    - clean code
+    - manage correctly all sdl events
+
+'''
+
+__all__ = ('WindowSDL', )
+
+from os.path import join
+import sys
+from typing import Optional
+from kivy import kivy_data_dir
+from kivy.logger import Logger
+from kivy.base import EventLoop
+from kivy.clock import Clock
+from kivy.config import Config
+from kivy.core.window import WindowBase
+try:
+    from kivy.core.window._window_sdl2 import _WindowSDL2Storage
+except ImportError:
+    from kivy.core import handle_win_lib_import_error
+    handle_win_lib_import_error(
+        'window', 'sdl2', 'kivy.core.window._window_sdl2')
+    raise
+from kivy.input.provider import MotionEventProvider
+from kivy.input.motionevent import MotionEvent
+from kivy.resources import resource_find
+from kivy.utils import platform, deprecated
+from kivy.compat import unichr
+from collections import deque
+
+
+# SDL_keycode.h, https://wiki.libsdl.org/SDL_Keymod
+KMOD_NONE = 0x0000
+KMOD_LSHIFT = 0x0001
+KMOD_RSHIFT = 0x0002
+KMOD_LCTRL = 0x0040
+KMOD_RCTRL = 0x0080
+KMOD_LALT = 0x0100
+KMOD_RALT = 0x0200
+KMOD_LGUI = 0x0400
+KMOD_RGUI = 0x0800
+KMOD_NUM = 0x1000
+KMOD_CAPS = 0x2000
+KMOD_MODE = 0x4000
+
+SDLK_SHIFTL = 1073742049
+SDLK_SHIFTR = 1073742053
+SDLK_LCTRL = 1073742048
+SDLK_RCTRL = 1073742052
+SDLK_LALT = 1073742050
+SDLK_RALT = 1073742054
+SDLK_LEFT = 1073741904
+SDLK_RIGHT = 1073741903
+SDLK_UP = 1073741906
+SDLK_DOWN = 1073741905
+SDLK_HOME = 1073741898
+SDLK_END = 1073741901
+SDLK_PAGEUP = 1073741899
+SDLK_PAGEDOWN = 1073741902
+SDLK_SUPER = 1073742051
+SDLK_CAPS = 1073741881
+SDLK_INSERT = 1073741897
+SDLK_KEYPADNUM = 1073741907
+SDLK_KP_DIVIDE = 1073741908
+SDLK_KP_MULTIPLY = 1073741909
+SDLK_KP_MINUS = 1073741910
+SDLK_KP_PLUS = 1073741911
+SDLK_KP_ENTER = 1073741912
+SDLK_KP_1 = 1073741913
+SDLK_KP_2 = 1073741914
+SDLK_KP_3 = 1073741915
+SDLK_KP_4 = 1073741916
+SDLK_KP_5 = 1073741917
+SDLK_KP_6 = 1073741918
+SDLK_KP_7 = 1073741919
+SDLK_KP_8 = 1073741920
+SDLK_KP_9 = 1073741921
+SDLK_KP_0 = 1073741922
+SDLK_KP_DOT = 1073741923
+SDLK_F1 = 1073741882
+SDLK_F2 = 1073741883
+SDLK_F3 = 1073741884
+SDLK_F4 = 1073741885
+SDLK_F5 = 1073741886
+SDLK_F6 = 1073741887
+SDLK_F7 = 1073741888
+SDLK_F8 = 1073741889
+SDLK_F9 = 1073741890
+SDLK_F10 = 1073741891
+SDLK_F11 = 1073741892
+SDLK_F12 = 1073741893
+SDLK_F13 = 1073741894
+SDLK_F14 = 1073741895
+SDLK_F15 = 1073741896
+
+
+class SDL2MotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'pressure')
+
+    def depack(self, args):
+        self.sx, self.sy, self.pressure = args
+        super().depack(args)
+
+
+class SDL2MotionEventProvider(MotionEventProvider):
+    win = None
+    q = deque()
+    touchmap = {}
+
+    def update(self, dispatch_fn):
+        touchmap = self.touchmap
+        while True:
+            try:
+                value = self.q.pop()
+            except IndexError:
+                return
+
+            action, fid, x, y, pressure = value
+            y = 1 - y
+            if fid not in touchmap:
+                touchmap[fid] = me = SDL2MotionEvent(
+                    'sdl', fid, (x, y, pressure)
+                )
+            else:
+                me = touchmap[fid]
+                me.move((x, y, pressure))
+            if action == 'fingerdown':
+                dispatch_fn('begin', me)
+            elif action == 'fingerup':
+                me.update_time_end()
+                dispatch_fn('end', me)
+                del touchmap[fid]
+            else:
+                dispatch_fn('update', me)
+
+
+class WindowSDL(WindowBase):
+
+    _win_dpi_watch: Optional['_WindowsSysDPIWatch'] = None
+
+    _do_resize_ev = None
+
+    managed_textinput = True
+
+    def __init__(self, **kwargs):
+        self._pause_loop = False
+        self._cursor_entered = False
+        self._drop_pos = None
+        self._win = _WindowSDL2Storage()
+        super(WindowSDL, self).__init__()
+        self.titlebar_widget = None
+        self._mouse_x = self._mouse_y = -1
+        self._meta_keys = (
+            KMOD_LCTRL, KMOD_RCTRL, KMOD_RSHIFT,
+            KMOD_LSHIFT, KMOD_RALT, KMOD_LALT, KMOD_LGUI,
+            KMOD_RGUI, KMOD_NUM, KMOD_CAPS, KMOD_MODE)
+        self.command_keys = {
+                    27: 'escape',
+                    9: 'tab',
+                    8: 'backspace',
+                    13: 'enter',
+                    127: 'del',
+                    271: 'enter',
+                    273: 'up',
+                    274: 'down',
+                    275: 'right',
+                    276: 'left',
+                    278: 'home',
+                    279: 'end',
+                    280: 'pgup',
+                    281: 'pgdown'}
+        self._mouse_buttons_down = set()
+        self.key_map = {SDLK_LEFT: 276, SDLK_RIGHT: 275, SDLK_UP: 273,
+                        SDLK_DOWN: 274, SDLK_HOME: 278, SDLK_END: 279,
+                        SDLK_PAGEDOWN: 281, SDLK_PAGEUP: 280, SDLK_SHIFTR: 303,
+                        SDLK_SHIFTL: 304, SDLK_SUPER: 309, SDLK_LCTRL: 305,
+                        SDLK_RCTRL: 306, SDLK_LALT: 308, SDLK_RALT: 307,
+                        SDLK_CAPS: 301, SDLK_INSERT: 277, SDLK_F1: 282,
+                        SDLK_F2: 283, SDLK_F3: 284, SDLK_F4: 285, SDLK_F5: 286,
+                        SDLK_F6: 287, SDLK_F7: 288, SDLK_F8: 289, SDLK_F9: 290,
+                        SDLK_F10: 291, SDLK_F11: 292, SDLK_F12: 293,
+                        SDLK_F13: 294, SDLK_F14: 295, SDLK_F15: 296,
+                        SDLK_KEYPADNUM: 300, SDLK_KP_DIVIDE: 267,
+                        SDLK_KP_MULTIPLY: 268, SDLK_KP_MINUS: 269,
+                        SDLK_KP_PLUS: 270, SDLK_KP_ENTER: 271,
+                        SDLK_KP_DOT: 266, SDLK_KP_0: 256, SDLK_KP_1: 257,
+                        SDLK_KP_2: 258, SDLK_KP_3: 259, SDLK_KP_4: 260,
+                        SDLK_KP_5: 261, SDLK_KP_6: 262, SDLK_KP_7: 263,
+                        SDLK_KP_8: 264, SDLK_KP_9: 265}
+        if platform == 'ios':
+            # XXX ios keyboard suck, when backspace is hit, the delete
+            # keycode is sent. fix it.
+            self.key_map[127] = 8
+        elif platform == 'android':
+            # map android back button to escape
+            self.key_map[1073742094] = 27
+
+        self.bind(minimum_width=self._set_minimum_size,
+                  minimum_height=self._set_minimum_size)
+
+        self.bind(allow_screensaver=self._set_allow_screensaver)
+
+    def get_window_info(self):
+        return self._win.get_window_info()
+
+    def _set_minimum_size(self, *args):
+        minimum_width = self.minimum_width
+        minimum_height = self.minimum_height
+        if minimum_width and minimum_height:
+            self._win.set_minimum_size(minimum_width, minimum_height)
+        elif minimum_width or minimum_height:
+            Logger.warning(
+                'Both Window.minimum_width and Window.minimum_height must be '
+                'bigger than 0 for the size restriction to take effect.')
+
+    def _set_allow_screensaver(self, *args):
+        self._win.set_allow_screensaver(self.allow_screensaver)
+
+    def _event_filter(self, action, *largs):
+        from kivy.app import App
+        if action == 'app_terminating':
+            EventLoop.quit = True
+
+        elif action == 'app_lowmemory':
+            self.dispatch('on_memorywarning')
+
+        elif action == 'app_willenterbackground':
+            from kivy.base import stopTouchApp
+            app = App.get_running_app()
+            if not app:
+                Logger.info('WindowSDL: No running App found, pause.')
+
+            elif not app.dispatch('on_pause'):
+                Logger.info(
+                    'WindowSDL: App doesn\'t support pause mode, stop.')
+                stopTouchApp()
+                return 0
+
+            self._pause_loop = True
+
+        elif action == 'app_didenterforeground':
+            # on iOS, the did enter foreground is launched at the start
+            # of the application. in our case, we want it only when the app
+            # is resumed
+            if self._pause_loop:
+                self._pause_loop = False
+                app = App.get_running_app()
+                if app:
+                    app.dispatch('on_resume')
+
+        elif action == 'windowresized':
+            self._size = largs
+            self._win.resize_window(*self._size)
+            # Force kivy to render the frame now, so that the canvas is drawn.
+            EventLoop.idle()
+
+        return 0
+
+    def create_window(self, *largs):
+        if self._fake_fullscreen:
+            if not self.borderless:
+                self.fullscreen = self._fake_fullscreen = False
+            elif not self.fullscreen or self.fullscreen == 'auto':
+                self.custom_titlebar = \
+                    self.borderless = self._fake_fullscreen = False
+            elif self.custom_titlebar:
+                if platform == 'win':
+                    # use custom behaviour
+                    # To handle aero snapping and rounded corners
+                    self.borderless = False
+        if self.fullscreen == 'fake':
+            self.borderless = self._fake_fullscreen = True
+            Logger.warning("The 'fake' fullscreen option has been "
+                           "deprecated, use Window.borderless or the "
+                           "borderless Config option instead.")
+
+        if not self.initialized:
+            if self.position == 'auto':
+                pos = None, None
+            elif self.position == 'custom':
+                pos = self.left, self.top
+
+            # ensure we have an event filter
+            self._win.set_event_filter(self._event_filter)
+
+            # setup window
+            w, h = self.system_size
+            resizable = Config.getboolean('graphics', 'resizable')
+            state = (Config.get('graphics', 'window_state')
+                     if self._is_desktop else None)
+            self.system_size = _size = self._win.setup_window(
+                pos[0], pos[1], w, h, self.borderless,
+                self.fullscreen, resizable, state,
+                self.get_gl_backend_name())
+
+            # calculate density/dpi
+            if platform == 'win':
+                from ctypes import windll
+                self._density = 1.
+                try:
+                    hwnd = windll.user32.GetActiveWindow()
+                    self.dpi = float(windll.user32.GetDpiForWindow(hwnd))
+                except AttributeError:
+                    pass
+            else:
+                sz = self._win._get_gl_size()[0]
+                self._density = density = sz / _size[0]
+                if self._is_desktop and self.size[0] != _size[0]:
+                    self.dpi = density * 96.
+
+            # never stay with a None pos, application using w.center
+            # will be fired.
+            self._pos = (0, 0)
+            self._set_minimum_size()
+            self._set_allow_screensaver()
+
+            if state == 'hidden':
+                self._focus = False
+        else:
+            w, h = self.system_size
+            self._win.resize_window(w, h)
+            if platform == 'win':
+                if self.custom_titlebar:
+                    # check dragging+resize or just dragging
+                    if Config.getboolean('graphics', 'resizable'):
+                        import win32con
+                        import ctypes
+                        self._win.set_border_state(False)
+                        # make windows dispatch,
+                        # WM_NCCALCSIZE explicitly
+                        ctypes.windll.user32.SetWindowPos(
+                            self._win.get_window_info().window,
+                            win32con.HWND_TOP,
+                            *self._win.get_window_pos(),
+                            *self.system_size,
+                            win32con.SWP_FRAMECHANGED
+                        )
+                    else:
+                        self._win.set_border_state(True)
+                else:
+                    self._win.set_border_state(self.borderless)
+            else:
+                self._win.set_border_state(self.borderless
+                                           or self.custom_titlebar)
+            self._win.set_fullscreen_mode(self.fullscreen)
+
+        super(WindowSDL, self).create_window()
+        # set mouse visibility
+        self._set_cursor_state(self.show_cursor)
+
+        if self.initialized:
+            return
+
+        # auto add input provider
+        Logger.info('Window: auto add sdl2 input provider')
+        from kivy.base import EventLoop
+        SDL2MotionEventProvider.win = self
+        EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', ''))
+
+        # set window icon before calling set_mode
+        try:
+            filename_icon = self.icon or Config.get('kivy', 'window_icon')
+            if filename_icon == '':
+                logo_size = 32
+                if platform == 'macosx':
+                    logo_size = 512
+                elif platform == 'win':
+                    logo_size = 64
+                filename_icon = 'kivy-icon-{}.png'.format(logo_size)
+                filename_icon = resource_find(
+                        join(kivy_data_dir, 'logo', filename_icon))
+            self.set_icon(filename_icon)
+        except:
+            Logger.exception('Window: cannot set icon')
+
+        if platform == 'win' and self._win_dpi_watch is None:
+            self._win_dpi_watch = _WindowsSysDPIWatch(window=self)
+            self._win_dpi_watch.start()
+
+    def close(self):
+        self._win.teardown_window()
+        super(WindowSDL, self).close()
+        if self._win_dpi_watch is not None:
+            self._win_dpi_watch.stop()
+            self._win_dpi_watch = None
+
+        self.initialized = False
+
+    def maximize(self):
+        if self._is_desktop:
+            self._win.maximize_window()
+        else:
+            Logger.warning('Window: maximize() is used only on desktop OSes.')
+
+    def minimize(self):
+        if self._is_desktop:
+            self._win.minimize_window()
+        else:
+            Logger.warning('Window: minimize() is used only on desktop OSes.')
+
+    def restore(self):
+        if self._is_desktop:
+            self._win.restore_window()
+        else:
+            Logger.warning('Window: restore() is used only on desktop OSes.')
+
+    def hide(self):
+        if self._is_desktop:
+            self._win.hide_window()
+        else:
+            Logger.warning('Window: hide() is used only on desktop OSes.')
+
+    def show(self):
+        if self._is_desktop:
+            self._win.show_window()
+        else:
+            Logger.warning('Window: show() is used only on desktop OSes.')
+
+    def raise_window(self):
+        if self._is_desktop:
+            self._win.raise_window()
+        else:
+            Logger.warning('Window: show() is used only on desktop OSes.')
+
+    @deprecated
+    def toggle_fullscreen(self):
+        if self.fullscreen in (True, 'auto'):
+            self.fullscreen = False
+        else:
+            self.fullscreen = 'auto'
+
+    def set_title(self, title):
+        self._win.set_window_title(title)
+
+    def set_icon(self, filename):
+        self._win.set_window_icon(str(filename))
+
+    def screenshot(self, *largs, **kwargs):
+        filename = super(WindowSDL, self).screenshot(*largs, **kwargs)
+        if filename is None:
+            return
+
+        from kivy.graphics.opengl import glReadPixels, GL_RGB, GL_UNSIGNED_BYTE
+        width, height = self.size
+        data = glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE)
+        self._win.save_bytes_in_png(filename, data, width, height)
+        Logger.debug('Window: Screenshot saved at <%s>' % filename)
+        return filename
+
+    def flip(self):
+        self._win.flip()
+        super(WindowSDL, self).flip()
+
+    def set_system_cursor(self, cursor_name):
+        result = self._win.set_system_cursor(cursor_name)
+        return result
+
+    def _get_window_pos(self):
+        return self._win.get_window_pos()
+
+    def _set_window_pos(self, x, y):
+        self._win.set_window_pos(x, y)
+
+    # Transparent Window background
+    def _is_shaped(self):
+        return self._win.is_window_shaped()
+
+    def _set_shape(self, shape_image, mode='default',
+                   cutoff=False, color_key=None):
+        modes = ('default', 'binalpha', 'reversebinalpha', 'colorkey')
+        color_key = color_key or (0, 0, 0, 1)
+        if mode not in modes:
+            Logger.warning(
+                'Window: shape mode can be only '
+                '{}'.format(', '.join(modes))
+            )
+            return
+        if not isinstance(color_key, (tuple, list)):
+            return
+        if len(color_key) not in (3, 4):
+            return
+        if len(color_key) == 3:
+            color_key = (color_key[0], color_key[1], color_key[2], 1)
+            Logger.warning(
+                'Window: Shape color_key must be only tuple or list'
+            )
+            return
+        color_key = (
+            color_key[0] * 255,
+            color_key[1] * 255,
+            color_key[2] * 255,
+            color_key[3] * 255
+        )
+
+        assert cutoff in (1, 0)
+        shape_image = shape_image or Config.get('kivy', 'window_shape')
+        shape_image = resource_find(shape_image) or shape_image
+        self._win.set_shape(shape_image, mode, cutoff, color_key)
+
+    def _get_shaped_mode(self):
+        return self._win.get_shaped_mode()
+
+    def _set_shaped_mode(self, value):
+        self._set_shape(
+            shape_image=self.shape_image,
+            mode=value, cutoff=self.shape_cutoff,
+            color_key=self.shape_color_key
+        )
+        return self._win.get_shaped_mode()
+    # twb end
+
+    def _set_cursor_state(self, value):
+        self._win._set_cursor_state(value)
+
+    def _fix_mouse_pos(self, x, y):
+        self.mouse_pos = (
+            x * self._density,
+            (self.system_size[1] - 1 - y) * self._density
+        )
+        return x, y
+
+    def mainloop(self):
+        # for android/iOS, we don't want to have any event nor executing our
+        # main loop while the pause is going on. This loop wait any event (not
+        # handled by the event filter), and remove them from the queue.
+        # Nothing happen during the pause on iOS, except gyroscope value sent
+        # over joystick. So it's safe.
+        while self._pause_loop:
+            self._win.wait_event()
+            if not self._pause_loop:
+                break
+            event = self._win.poll()
+            if event is None:
+                continue
+            # A drop is send while the app is still in pause.loop
+            # we need to dispatch it
+            action, args = event[0], event[1:]
+            if action.startswith('drop'):
+                self._dispatch_drop_event(action, args)
+            # app_terminating event might be received while the app is paused
+            # in this case EventLoop.quit will be set at _event_filter
+            elif EventLoop.quit:
+                return
+
+        while True:
+            event = self._win.poll()
+            if event is False:
+                break
+            if event is None:
+                continue
+
+            action, args = event[0], event[1:]
+            if action == 'quit':
+                if self.dispatch('on_request_close'):
+                    continue
+                EventLoop.quit = True
+                break
+
+            elif action in ('fingermotion', 'fingerdown', 'fingerup'):
+                # for finger, pass the raw event to SDL motion event provider
+                # XXX this is problematic. On OSX, it generates touches with 0,
+                # 0 coordinates, at the same times as mouse. But it works.
+                # We have a conflict of using either the mouse or the finger.
+                # Right now, we have no mechanism that we could use to know
+                # which is the preferred one for the application.
+                if platform in ('ios', 'android'):
+                    SDL2MotionEventProvider.q.appendleft(event)
+                pass
+
+            elif action == 'mousemotion':
+                x, y = args
+                x, y = self._fix_mouse_pos(x, y)
+                self._mouse_x = x
+                self._mouse_y = y
+                if not self._cursor_entered:
+                    self._cursor_entered = True
+                    self.dispatch('on_cursor_enter')
+                # don't dispatch motion if no button are pressed
+                if len(self._mouse_buttons_down) == 0:
+                    continue
+                self._mouse_meta = self.modifiers
+                self.dispatch('on_mouse_move', x, y, self.modifiers)
+
+            elif action in ('mousebuttondown', 'mousebuttonup'):
+                x, y, button = args
+                x, y = self._fix_mouse_pos(x, y)
+                self._mouse_x = x
+                self._mouse_y = y
+                if not self._cursor_entered:
+                    self._cursor_entered = True
+                    self.dispatch('on_cursor_enter')
+                btn = 'left'
+                if button == 3:
+                    btn = 'right'
+                elif button == 2:
+                    btn = 'middle'
+                elif button == 4:
+                    btn = "mouse4"
+                elif button == 5:
+                    btn = "mouse5"
+                eventname = 'on_mouse_down'
+                self._mouse_buttons_down.add(button)
+                if action == 'mousebuttonup':
+                    eventname = 'on_mouse_up'
+                    self._mouse_buttons_down.remove(button)
+                self.dispatch(eventname, x, y, btn, self.modifiers)
+            elif action.startswith('mousewheel'):
+                x, y = self._win.get_relative_mouse_pos()
+                if not self._collide_and_dispatch_cursor_enter(x, y):
+                    # Ignore if the cursor position is on the window title bar
+                    # or on its edges
+                    continue
+                self._update_modifiers()
+                x, y, button = args
+                btn = 'scrolldown'
+                if action.endswith('up'):
+                    btn = 'scrollup'
+                elif action.endswith('right'):
+                    btn = 'scrollright'
+                elif action.endswith('left'):
+                    btn = 'scrollleft'
+
+                self._mouse_meta = self.modifiers
+                self._mouse_btn = btn
+                # times = x if y == 0 else y
+                # times = min(abs(times), 100)
+                # for k in range(times):
+                self._mouse_down = True
+                self.dispatch('on_mouse_down',
+                    self._mouse_x, self._mouse_y, btn, self.modifiers)
+                self._mouse_down = False
+                self.dispatch('on_mouse_up',
+                    self._mouse_x, self._mouse_y, btn, self.modifiers)
+
+            elif action.startswith('drop'):
+                self._dispatch_drop_event(action, args)
+            # video resize
+            elif action == 'windowresized':
+                self._size = self._win.window_size
+                # don't use trigger here, we want to delay the resize event
+                ev = self._do_resize_ev
+                if ev is None:
+                    ev = Clock.schedule_once(self._do_resize, .1)
+                    self._do_resize_ev = ev
+                else:
+                    ev()
+
+            elif action == 'windowmoved':
+                self.dispatch('on_move')
+
+            elif action == 'windowrestored':
+                self.dispatch('on_restore')
+                self.canvas.ask_update()
+
+            elif action == 'windowexposed':
+                self.canvas.ask_update()
+
+            elif action == 'windowminimized':
+                self.dispatch('on_minimize')
+                if Config.getboolean('kivy', 'pause_on_minimize'):
+                    self.do_pause()
+
+            elif action == 'windowmaximized':
+                self.dispatch('on_maximize')
+
+            elif action == 'windowhidden':
+                self.dispatch('on_hide')
+
+            elif action == 'windowshown':
+                self.dispatch('on_show')
+
+            elif action == 'windowfocusgained':
+                self._focus = True
+
+            elif action == 'windowfocuslost':
+                self._focus = False
+
+            elif action == 'windowenter':
+                x, y = self._win.get_relative_mouse_pos()
+                self._collide_and_dispatch_cursor_enter(x, y)
+
+            elif action == 'windowleave':
+                self._cursor_entered = False
+                self.dispatch('on_cursor_leave')
+
+            elif action == 'joyaxismotion':
+                stickid, axisid, value = args
+                self.dispatch('on_joy_axis', stickid, axisid, value)
+            elif action == 'joyhatmotion':
+                stickid, hatid, value = args
+                self.dispatch('on_joy_hat', stickid, hatid, value)
+            elif action == 'joyballmotion':
+                stickid, ballid, xrel, yrel = args
+                self.dispatch('on_joy_ball', stickid, ballid, xrel, yrel)
+            elif action == 'joybuttondown':
+                stickid, buttonid = args
+                self.dispatch('on_joy_button_down', stickid, buttonid)
+            elif action == 'joybuttonup':
+                stickid, buttonid = args
+                self.dispatch('on_joy_button_up', stickid, buttonid)
+
+            elif action in ('keydown', 'keyup'):
+                mod, key, scancode, kstr = args
+
+                try:
+                    key = self.key_map[key]
+                except KeyError:
+                    pass
+
+                if action == 'keydown':
+                    self._update_modifiers(mod, key)
+                else:
+                    # ignore the key, it has been released
+                    self._update_modifiers(mod)
+
+                # if mod in self._meta_keys:
+                if (key not in self._modifiers and
+                        key not in self.command_keys.keys()):
+                    try:
+                        kstr_chr = unichr(key)
+                        try:
+                            # On android, there is no 'encoding' attribute.
+                            # On other platforms, if stdout is redirected,
+                            # 'encoding' may be None
+                            encoding = getattr(sys.stdout, 'encoding',
+                                               'utf8') or 'utf8'
+                            kstr_chr.encode(encoding)
+                            kstr = kstr_chr
+                        except UnicodeError:
+                            pass
+                    except ValueError:
+                        pass
+                # if 'shift' in self._modifiers and key\
+                #        not in self.command_keys.keys():
+                #    return
+
+                if action == 'keyup':
+                    self.dispatch('on_key_up', key, scancode)
+                    continue
+
+                # don't dispatch more key if down event is accepted
+                if self.dispatch('on_key_down', key,
+                                 scancode, kstr,
+                                 self.modifiers):
+                    continue
+                self.dispatch('on_keyboard', key,
+                              scancode, kstr,
+                              self.modifiers)
+
+            elif action == 'textinput':
+                text = args[0]
+                self.dispatch('on_textinput', text)
+
+            elif action == 'textedit':
+                text = args[0]
+                self.dispatch('on_textedit', text)
+
+            # unhandled event !
+            else:
+                Logger.trace('WindowSDL: Unhandled event %s' % str(event))
+
+    def _dispatch_drop_event(self, action, args):
+        x, y = (0, 0) if self._drop_pos is None else self._drop_pos
+        if action == 'dropfile':
+            self.dispatch('on_drop_file', args[0], x, y)
+        elif action == 'droptext':
+            self.dispatch('on_drop_text', args[0], x, y)
+        elif action == 'dropbegin':
+            self._drop_pos = x, y = self._win.get_relative_mouse_pos()
+            self._collide_and_dispatch_cursor_enter(x, y)
+            self.dispatch('on_drop_begin', x, y)
+        elif action == 'dropend':
+            self._drop_pos = None
+            self.dispatch('on_drop_end', x, y)
+
+    def _collide_and_dispatch_cursor_enter(self, x, y):
+        # x, y are relative to window left/top position
+        w, h = self._win.window_size
+        if 0 <= x < w and 0 <= y < h:
+            self._mouse_x, self._mouse_y = self._fix_mouse_pos(x, y)
+            if not self._cursor_entered:
+                self._cursor_entered = True
+                self.dispatch('on_cursor_enter')
+            return True
+
+    def _do_resize(self, dt):
+        Logger.debug('Window: Resize window to %s' % str(self.size))
+        self._win.resize_window(*self._size)
+        self.dispatch('on_pre_resize', *self.size)
+
+    def do_pause(self):
+        # should go to app pause mode (desktop style)
+        from kivy.app import App
+        from kivy.base import stopTouchApp
+        app = App.get_running_app()
+        if not app:
+            Logger.info('WindowSDL: No running App found, pause.')
+        elif not app.dispatch('on_pause'):
+            Logger.info('WindowSDL: App doesn\'t support pause mode, stop.')
+            stopTouchApp()
+            return
+
+        # XXX FIXME wait for sdl resume
+        while True:
+            event = self._win.poll()
+            if event is False:
+                continue
+            if event is None:
+                continue
+
+            action, args = event[0], event[1:]
+            if action == 'quit':
+                EventLoop.quit = True
+                break
+            elif action == 'app_willenterforeground':
+                break
+            elif action == 'windowrestored':
+                break
+
+        if app:
+            app.dispatch('on_resume')
+
+    def _update_modifiers(self, mods=None, key=None):
+        if mods is None and key is None:
+            return
+        modifiers = set()
+
+        if mods is not None:
+            if mods & (KMOD_RSHIFT | KMOD_LSHIFT):
+                modifiers.add('shift')
+            if mods & (KMOD_RALT | KMOD_LALT | KMOD_MODE):
+                modifiers.add('alt')
+            if mods & (KMOD_RCTRL | KMOD_LCTRL):
+                modifiers.add('ctrl')
+            if mods & (KMOD_RGUI | KMOD_LGUI):
+                modifiers.add('meta')
+            if mods & KMOD_NUM:
+                modifiers.add('numlock')
+            if mods & KMOD_CAPS:
+                modifiers.add('capslock')
+
+        if key is not None:
+            if key in (KMOD_RSHIFT, KMOD_LSHIFT):
+                modifiers.add('shift')
+            if key in (KMOD_RALT, KMOD_LALT, KMOD_MODE):
+                modifiers.add('alt')
+            if key in (KMOD_RCTRL, KMOD_LCTRL):
+                modifiers.add('ctrl')
+            if key in (KMOD_RGUI, KMOD_LGUI):
+                modifiers.add('meta')
+            if key == KMOD_NUM:
+                modifiers.add('numlock')
+            if key == KMOD_CAPS:
+                modifiers.add('capslock')
+
+        self._modifiers = list(modifiers)
+        return
+
+    def request_keyboard(
+            self, callback, target, input_type='text', keyboard_suggestions=True
+    ):
+        self._sdl_keyboard = super(WindowSDL, self).\
+            request_keyboard(
+            callback, target, input_type, keyboard_suggestions
+        )
+        self._win.show_keyboard(
+            self._system_keyboard,
+            self.softinput_mode,
+            input_type,
+            keyboard_suggestions,
+        )
+        Clock.schedule_interval(self._check_keyboard_shown, 1 / 5.)
+        return self._sdl_keyboard
+
+    def release_keyboard(self, *largs):
+        super(WindowSDL, self).release_keyboard(*largs)
+        self._win.hide_keyboard()
+        self._sdl_keyboard = None
+        return True
+
+    def _check_keyboard_shown(self, dt):
+        if self._sdl_keyboard is None:
+            return False
+        if not self._win.is_keyboard_shown():
+            self._sdl_keyboard.release()
+
+    def map_key(self, original_key, new_key):
+        self.key_map[original_key] = new_key
+
+    def unmap_key(self, key):
+        if key in self.key_map:
+            del self.key_map[key]
+
+    def grab_mouse(self):
+        self._win.grab_mouse(True)
+
+    def ungrab_mouse(self):
+        self._win.grab_mouse(False)
+
+    def set_custom_titlebar(self, titlebar_widget):
+        if not self.custom_titlebar:
+            Logger.warning("Window: Window.custom_titlebar not set to True… "
+                           "can't set custom titlebar")
+            return
+        self.titlebar_widget = titlebar_widget
+        return self._win.set_custom_titlebar(self.titlebar_widget) == 0
+
+
+class _WindowsSysDPIWatch:
+
+    hwnd = None
+
+    new_windProc = None
+
+    old_windProc = None
+
+    window: WindowBase = None
+
+    def __init__(self, window: WindowBase):
+        self.window = window
+
+    def start(self):
+        from kivy.input.providers.wm_common import WNDPROC, \
+            SetWindowLong_WndProc_wrapper
+        from ctypes import windll
+
+        self.hwnd = windll.user32.GetActiveWindow()
+
+        # inject our own handler to handle messages before window manager
+        self.new_windProc = WNDPROC(self._wnd_proc)
+        self.old_windProc = SetWindowLong_WndProc_wrapper(
+            self.hwnd, self.new_windProc)
+
+    def stop(self):
+        from kivy.input.providers.wm_common import \
+            SetWindowLong_WndProc_wrapper
+
+        if self.hwnd is None:
+            return
+
+        self.new_windProc = SetWindowLong_WndProc_wrapper(
+            self.hwnd, self.old_windProc)
+        self.hwnd = self.new_windProc = self.old_windProc = None
+
+    def _wnd_proc(self, hwnd, msg, wParam, lParam):
+        from kivy.input.providers.wm_common import WM_DPICHANGED, WM_NCCALCSIZE
+        from ctypes import windll
+
+        if msg == WM_DPICHANGED:
+            ow, oh = self.window.size
+            old_dpi = self.window.dpi
+
+            def clock_callback(*args):
+                if x_dpi != y_dpi:
+                    raise ValueError(
+                        'Can only handle DPI that are same for x and y')
+
+                self.window.dpi = x_dpi
+
+                # maintain the same window size
+                ratio = x_dpi / old_dpi
+                self.window.size = ratio * ow, ratio * oh
+
+            x_dpi = wParam & 0xFFFF
+            y_dpi = wParam >> 16
+            Clock.schedule_once(clock_callback, -1)
+        elif Config.getboolean('graphics', 'resizable') \
+                and msg == WM_NCCALCSIZE and self.window.custom_titlebar:
+            return 0
+        return windll.user32.CallWindowProcW(
+            self.old_windProc, hwnd, msg, wParam, lParam)
diff --git a/kivy/core/window/window_x11.cpython-310-x86_64-linux-gnu.so b/kivy/core/window/window_x11.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..8457d41
Binary files /dev/null and b/kivy/core/window/window_x11.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/data/fonts/DejaVuSans.ttf b/kivy/data/fonts/DejaVuSans.ttf
new file mode 100644
index 0000000..9d40c32
Binary files /dev/null and b/kivy/data/fonts/DejaVuSans.ttf differ
diff --git a/kivy/data/fonts/Roboto-Bold.ttf b/kivy/data/fonts/Roboto-Bold.ttf
new file mode 100644
index 0000000..a355c27
Binary files /dev/null and b/kivy/data/fonts/Roboto-Bold.ttf differ
diff --git a/kivy/data/fonts/Roboto-BoldItalic.ttf b/kivy/data/fonts/Roboto-BoldItalic.ttf
new file mode 100644
index 0000000..3c9a7a3
Binary files /dev/null and b/kivy/data/fonts/Roboto-BoldItalic.ttf differ
diff --git a/kivy/data/fonts/Roboto-Italic.ttf b/kivy/data/fonts/Roboto-Italic.ttf
new file mode 100644
index 0000000..ff6046d
Binary files /dev/null and b/kivy/data/fonts/Roboto-Italic.ttf differ
diff --git a/kivy/data/fonts/Roboto-Regular.ttf b/kivy/data/fonts/Roboto-Regular.ttf
new file mode 100644
index 0000000..8c082c8
Binary files /dev/null and b/kivy/data/fonts/Roboto-Regular.ttf differ
diff --git a/kivy/data/fonts/RobotoMono-Regular.ttf b/kivy/data/fonts/RobotoMono-Regular.ttf
new file mode 100644
index 0000000..b158a33
Binary files /dev/null and b/kivy/data/fonts/RobotoMono-Regular.ttf differ
diff --git a/kivy/data/glsl/default.fs b/kivy/data/glsl/default.fs
new file mode 100644
index 0000000..19145d6
--- /dev/null
+++ b/kivy/data/glsl/default.fs
@@ -0,0 +1,4 @@
+$HEADER$
+void main (void){
+    gl_FragColor = frag_color * texture2D(texture0, tex_coord0);
+}
diff --git a/kivy/data/glsl/default.png b/kivy/data/glsl/default.png
new file mode 100644
index 0000000..308bfe2
Binary files /dev/null and b/kivy/data/glsl/default.png differ
diff --git a/kivy/data/glsl/default.vs b/kivy/data/glsl/default.vs
new file mode 100644
index 0000000..ac9ac4d
--- /dev/null
+++ b/kivy/data/glsl/default.vs
@@ -0,0 +1,6 @@
+$HEADER$
+void main (void) {
+  frag_color = color * vec4(1.0, 1.0, 1.0, opacity);
+  tex_coord0 = vTexCoords0;
+  gl_Position = projection_mat * modelview_mat * vec4(vPosition.xy, 0.0, 1.0);
+}
diff --git a/kivy/data/glsl/header.fs b/kivy/data/glsl/header.fs
new file mode 100644
index 0000000..cd38cc9
--- /dev/null
+++ b/kivy/data/glsl/header.fs
@@ -0,0 +1,12 @@
+#ifdef GL_ES
+    precision highp float;
+#endif
+
+/* Outputs from the vertex shader */
+varying vec4 frag_color;
+varying vec2 tex_coord0;
+
+/* uniform texture samplers */
+uniform sampler2D texture0;
+
+uniform mat4 frag_modelview_mat;
diff --git a/kivy/data/glsl/header.vs b/kivy/data/glsl/header.vs
new file mode 100644
index 0000000..a2638bf
--- /dev/null
+++ b/kivy/data/glsl/header.vs
@@ -0,0 +1,17 @@
+#ifdef GL_ES
+    precision highp float;
+#endif
+
+/* Outputs to the fragment shader */
+varying vec4 frag_color;
+varying vec2 tex_coord0;
+
+/* vertex attributes */
+attribute vec2     vPosition;
+attribute vec2     vTexCoords0;
+
+/* uniform variables */
+uniform mat4       modelview_mat;
+uniform mat4       projection_mat;
+uniform vec4       color;
+uniform float      opacity;
diff --git a/kivy/data/images/background.jpg b/kivy/data/images/background.jpg
new file mode 100644
index 0000000..57ab046
Binary files /dev/null and b/kivy/data/images/background.jpg differ
diff --git a/kivy/data/images/cursor.png b/kivy/data/images/cursor.png
new file mode 100644
index 0000000..4151088
Binary files /dev/null and b/kivy/data/images/cursor.png differ
diff --git a/kivy/data/images/defaultshape.png b/kivy/data/images/defaultshape.png
new file mode 100644
index 0000000..ae02f8c
Binary files /dev/null and b/kivy/data/images/defaultshape.png differ
diff --git a/kivy/data/images/defaulttheme-0.png b/kivy/data/images/defaulttheme-0.png
new file mode 100644
index 0000000..d72f3b3
Binary files /dev/null and b/kivy/data/images/defaulttheme-0.png differ
diff --git a/kivy/data/images/defaulttheme.atlas b/kivy/data/images/defaulttheme.atlas
new file mode 100644
index 0000000..7bf086d
--- /dev/null
+++ b/kivy/data/images/defaulttheme.atlas
@@ -0,0 +1 @@
+{"defaulttheme-0.png": {"progressbar_background": [392, 227, 24, 24], "tab_btn_disabled": [332, 137, 32, 32], "tab_btn_pressed": [400, 137, 32, 32], "image-missing": [152, 171, 48, 48], "splitter_h": [174, 123, 32, 7], "splitter_down": [11, 10, 7, 32], "splitter_disabled_down": [2, 10, 7, 32], "vkeyboard_key_down": [2, 44, 32, 32], "vkeyboard_disabled_key_down": [434, 137, 32, 32], "selector_right": [438, 326, 64, 64], "player-background": [2, 287, 103, 103], "selector_middle": [372, 326, 64, 64], "spinner": [204, 82, 29, 37], "tab_btn_disabled_pressed": [366, 137, 32, 32], "switch-button_disabled": [375, 291, 43, 32], "textinput_disabled_active": [134, 221, 64, 64], "splitter_grip": [70, 50, 12, 26], "vkeyboard_key_normal": [36, 44, 32, 32], "button_disabled": [111, 82, 29, 37], "media-playback-stop": [302, 171, 48, 48], "splitter": [502, 137, 7, 32], "splitter_down_h": [140, 123, 32, 7], "sliderh_background_disabled": [115, 132, 41, 37], "modalview-background": [464, 456, 45, 54], "button": [80, 82, 29, 37], "splitter_disabled": [501, 87, 7, 32], "checkbox_radio_disabled_on": [467, 87, 32, 32], "slider_cursor": [352, 171, 48, 48], "vkeyboard_disabled_background": [266, 221, 64, 64], "checkbox_disabled_on": [331, 87, 32, 32], "sliderv_background_disabled": [41, 78, 37, 41], "button_disabled_pressed": [142, 82, 29, 37], "audio-volume-muted": [102, 171, 48, 48], "close": [487, 173, 20, 20], "action_group_disabled": [2, 121, 33, 48], "vkeyboard_background": [200, 221, 64, 64], "checkbox_off": [365, 87, 32, 32], "tab_disabled": [107, 291, 96, 32], "sliderh_background": [72, 132, 41, 37], "switch-button": [430, 253, 43, 32], "tree_closed": [418, 231, 20, 20], "bubble_btn_pressed": [454, 291, 32, 32], "selector_left": [306, 326, 64, 64], "filechooser_file": [174, 326, 64, 64], "checkbox_radio_disabled_off": [433, 87, 32, 32], "checkbox_radio_on": [230, 137, 32, 32], "checkbox_on": [399, 87, 32, 32], "button_pressed": [173, 82, 29, 37], "audio-volume-high": [464, 406, 48, 48], "audio-volume-low": [2, 171, 48, 48], "progressbar": [332, 227, 32, 24], "previous_normal": [488, 291, 19, 32], "separator": [504, 342, 5, 48], "filechooser_folder": [240, 326, 64, 64], "checkbox_radio_off": [196, 137, 32, 32], "textinput_active": [68, 221, 64, 64], "textinput": [2, 221, 64, 64], "player-play-overlay": [122, 395, 117, 115], "media-playback-pause": [202, 171, 48, 48], "sliderv_background": [2, 78, 37, 41], "ring": [354, 402, 108, 108], "bubble_arrow": [490, 241, 16, 10], "slider_cursor_disabled": [402, 171, 48, 48], "checkbox_disabled_off": [297, 87, 32, 32], "action_group_down": [37, 121, 33, 48], "spinner_disabled": [235, 82, 29, 37], "splitter_disabled_h": [106, 123, 32, 7], "bubble": [107, 325, 65, 65], "media-playback-start": [252, 171, 48, 48], "vkeyboard_disabled_key_normal": [468, 137, 32, 32], "overflow": [264, 137, 32, 32], "tree_opened": [440, 231, 20, 20], "action_item": [487, 195, 24, 24], "bubble_btn": [420, 291, 32, 32], "audio-volume-medium": [52, 171, 48, 48], "action_group": [452, 171, 33, 48], "spinner_pressed": [266, 82, 29, 37], "filechooser_selected": [2, 392, 118, 118], "tab": [332, 253, 96, 32], "action_bar": [158, 133, 36, 36], "action_view": [366, 227, 24, 24], "tab_btn": [298, 137, 32, 32], "switch-background": [205, 291, 83, 32], "splitter_disabled_down_h": [72, 123, 32, 7], "action_item_down": [475, 253, 32, 32], "switch-background_disabled": [290, 291, 83, 32], "textinput_disabled": [241, 399, 111, 111], "splitter_grip_h": [462, 239, 26, 12]}}
\ No newline at end of file
diff --git a/kivy/data/images/image-loading.gif b/kivy/data/images/image-loading.gif
new file mode 100644
index 0000000..859f31b
Binary files /dev/null and b/kivy/data/images/image-loading.gif differ
diff --git a/kivy/data/images/image-loading.zip b/kivy/data/images/image-loading.zip
new file mode 100644
index 0000000..ac98293
Binary files /dev/null and b/kivy/data/images/image-loading.zip differ
diff --git a/kivy/data/images/testpattern.png b/kivy/data/images/testpattern.png
new file mode 100644
index 0000000..405e140
Binary files /dev/null and b/kivy/data/images/testpattern.png differ
diff --git a/kivy/data/keyboards/azerty.json b/kivy/data/keyboards/azerty.json
new file mode 100644
index 0000000..61b249b
--- /dev/null
+++ b/kivy/data/keyboards/azerty.json
@@ -0,0 +1,68 @@
+{
+    "title" : "Azerty",
+    "description" : "A French keyboard without international keys",
+    "cols" : 15,
+	"rows": 5,
+    "normal_1" : [
+        ["@", "@", "`", 1],    ["&", "&", "1", 1],    ["\u00e9", "\u00e9", "2", 1],
+        ["'", "'", "3", 1],    ["\"", "\"", "4", 1],  ["[", "[", "5", 1],
+        ["-", "-", "6", 1],    ["\u00e8", "\u00e8", "7", 1],    ["_", "_", "8", 1],
+        ["\u00e7", "\u00e7", "9", 1],    ["\u00e0", "\u00e0", "0", 1],    ["]", "]", "+", 1],
+        ["=", "=", "=", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "normal_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["a", "a", "a", 1],    ["z", "z", "z", 1],
+        ["e", "e", "e", 1],    ["r", "r", "r", 1],    ["t", "t", "t", 1],
+        ["y", "y", "y", 1],    ["u", "u", "u", 1],    ["i", "i", "i", 1],
+        ["o", "o", "o", 1],    ["p", "p", "p", 1],    ["^", "^", "^", 1],
+        ["$", "$", "}", 1],    ["\u23ce", null, "enter", 1.5]
+    ],
+    "normal_3" : [
+        ["\u21ea", null, "capslock", 1.8],  ["q", "q", "q", 1],    ["s", "s", "s", 1],
+        ["d", "d", "d", 1],    ["f", "f", "f", 1],    ["g", "g", "g", 1],
+        ["h", "h", "h", 1],    ["j", "j", "j", 1],    ["k", "k", "k", 1],
+        ["l", "l", "l", 1],    ["m", "m", "m", 1],    ["\u00f9", "\u00f9", "%", 1],
+        ["*", "*", "*", 1],    ["\u23ce", null, "enter", 1.2]
+    ],
+    "normal_4" : [
+        ["\u21e7", null, "shift", 1.5],  ["<", "<", null, 1],    ["w", "w", null, 1],
+        ["x", "x", null, 1],
+        ["c", "c", null, 1],    ["v", "v", null, 1],    ["b", "b", null, 1],
+        ["n", "n", null, 1],    [",", ",", null, 1],    [";", ";", null, 1],
+        [":", ":", null, 1],    ["!", "!", null, 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "normal_5" : [
+        [" ", " ", "spacebar", 12], ["\u2b12", null, "layout", 1.5], ["\u2a2f", null, "escape", 1.5]
+    ],
+    "shift_1" : [
+        ["|", "|", "|", 1],    ["1", "1", "1", 1],    ["2", "2", "2", 1],
+        ["3", "3", "3", 1],    ["4", "4", "4", 1],    ["5", "5", "5", 1],
+        ["6", "6", "6", 1],    ["7", "7", "7", 1],    ["8", "8", "8", 1],
+        ["9", "9", "9", 1],    ["0", "0", "0", 1],    ["#", "#", "#", 1],
+        ["+", "+", "+", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "shift_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["A", "A", "a", 1],    ["Z", "Z", null, 1],
+        ["E", "E", "e", 1],    ["R", "R", "r", 1],    ["T", "T", "t", 1],
+        ["Y", "Y", "y", 1],    ["U", "U", "u", 1],    ["I", "I", "i", 1],
+        ["O", "O", "o", 1],    ["P", "P", "p", 1],    ["[", "[", "[", 1],
+        ["]", "]", "]", 1],    ["\u23ce", null, "enter", 1.5]
+    ],
+    "shift_3" : [
+        ["\u21ea", null, "capslock", 1.8],  ["Q", "Q", "q", 1],    ["S", "S", "s", 1],
+        ["D", "D", "d", 1],    ["F", "F", "f", 1],    ["G", "G", "g", 1],
+        ["H", "H", "h", 1],    ["J", "J", "j", 1],    ["K", "K", "k", 1],
+        ["L", "L", "l", 1],    ["M", "M", "m", 1],    ["%", "%", "%", 1],
+        ["\u00b5", "\u00b5", "*", 1],    ["\u23ce", null, "enter", 1.2]
+    ],
+    "shift_4" : [
+        ["\u21e7", null, "shift", 1.5],  [">", ">", ">", 1],    ["W", "W", "w", 1],
+        ["X", "X", "x", 1],    ["C", "C", "c", 1],    ["V", "V", "v", 1],
+        ["B", "B", "b", 1],    ["N", "N", "n", 1],    ["?", "?", "?", 1],
+        [".", ".", ".", 1],    ["/", "/", "/", 1],    ["\u00a7", "\u00a7", "!", 1],
+        ["\u21e7", null, "shift", 2.5]
+    ],
+    "shift_5" : [
+        [" ", " ", "spacebar", 12], ["\u2b12", null, "layout", 1.5], ["\u2a2f", null, "escape", 1.5]
+    ]
+}
diff --git a/kivy/data/keyboards/de.json b/kivy/data/keyboards/de.json
new file mode 100644
index 0000000..24598a7
--- /dev/null
+++ b/kivy/data/keyboards/de.json
@@ -0,0 +1,101 @@
+{
+    "title": "de",
+    "description": "A true German keyboard",
+	"cols": 15,
+    "rows": 5,
+    "normal_1": [
+        ["^", "^", "^", 1],    ["1", "1", "1", 1],    ["2", "2", "2", 1],
+        ["3", "3", "3", 1],    ["4", "4", "4", 1],    ["5", "5", "5", 1],
+        ["6", "6", "6", 1],    ["7", "7", "7", 1],    ["8", "8", "8", 1],
+        ["9", "9", "9", 1],    ["0", "0", "0", 1],    ["ß", "ß", "ß", 1],
+        ["´", "´", "´", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "normal_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["q", "q", "q", 1],    ["w", "w", "w", 1],
+        ["e", "e", "e", 1],    ["r", "r", "r", 1],    ["t", "t", "t", 1],
+        ["z", "z", "z", 1],    ["u", "u", "´", 1],    ["i", "i", "i", 1],
+        ["o", "o", "o", 1],    ["p", "p", "p", 1],    ["ü", "ü", "ü", 1],
+        ["+", "+", "+", 1],    ["\u23ce", null, "enter", 1.5]
+    ],
+    "normal_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["a", "a", "a", 1],    ["s", "s", "s", 1],
+        ["d", "d", "d", 1],    ["f", "f", "f", 1],    ["g", "g", "g", 1],
+        ["h", "h", "h", 1],    ["j", "j", "j", 1],    ["k", "k", "k", 1],
+        ["l", "l", "l", 1],    ["ö", "ö", "ö", 1],    ["ä", "ä", "ä", 1],
+        ["#", "#", "#", 1],    ["\u23ce", null, "enter", 1.2]
+    ],
+    "normal_4": [
+        ["\u21e7", null, "shift", 1.5],  ["<", "<", "<", 1], ["y", "y", "y", 1],
+        ["x", "x", "x", 1],    ["c", "c", "c", 1],    ["v", "v", "v", 1],
+        ["b", "b", "b", 1],    ["n", "n", "n", 1],    ["m", "m", "m", 1],
+        [",", ",", ",", 1],    [".", ".", ".", 1],    ["-", "-", "-", 1],
+        ["\u21e7", null, "shift", 2.5]
+    ],
+    "normal_5": [
+        ["@€¿", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "shift_1": [
+        ["°", "°", "°", 1],    ["!", "!", "!", 1],    ["\"", "\"","\"", 1],
+        ["§", "§", "§", 1],    ["$", "$", "$", 1],    ["%", "%", "%", 1],
+        ["&", "&", "&", 1],    ["/", "/", "/", 1],    ["(", "(", "(", 1],
+        [")", ")", ")", 1],    ["=", "=", "=", 1],    ["?", "?", "?", 1],
+        ["`", "`", "`", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "shift_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["Q", "Q", null, 1],    ["W", "W", null, 1],
+        ["E", "E", "e", 1],    ["R", "R", "r", 1],    ["T", "T", "t", 1],
+        ["Z", "Z", "z", 1],    ["U", "U", "u", 1],    ["I", "I", "i", 1],
+        ["O", "O", "o", 1],    ["P", "P", "p", 1],    ["Ü", "Ü", "Ü", 1],
+        ["*", "*", "*", 1],    ["\u23ce", null, "enter", 1.5]
+    ],
+    "shift_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["A", "A", "a", 1],    ["S", "S", "s", 1],
+        ["D", "D", "d", 1],    ["F", "F", "f", 1],    ["G", "G", "g", 1],
+        ["H", "H", "h", 1],    ["J", "J", "j", 1],    ["K", "K", "k", 1],
+        ["L", "L", "l", 1],    ["Ö", "Ö", "Ö", 1],    ["Ä", "Ä", "Ä", 1],
+        ["'", "'", "'", 1],    ["\u23ce", null, "enter", 1.2]
+    ],
+    "shift_4": [
+        ["\u21e7", null, "shift", 1.5],  [">", ">", ">", 1],  ["Y", "Y", "Y", 1],
+        ["X", "X", "X", 1],    ["C", "C", "C", 1],    ["V", "V", "V", 1],
+        ["B", "B", "B", 1],    ["N", "N", "N", 1],    ["M", "M", "M", 1],
+        [";", ";", ";", 1],    [":", ":", ":", 1],    ["_", "_", "_", 1],
+        ["\u21e7", null, "shift", 2.5]
+    ],
+    "shift_5": [
+        ["@€¿", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "special_1": [
+        ["„", "„", "„", 1],    ["¡", "¡", "¡", 1],    ["“", "“", "“", 1],
+        ["¶", "¶", "¶", 1],    ["¢", "¢", "¢", 1],    ["[", "[", "[", 1],
+        ["]", "]", "]", 1],    ["|", "|", "|", 1],    ["{", "{", "{", 1],
+        ["}", "}", "}", 1],    ["≠", "≠", "≠", 1],    ["¿", "¿", "¿", 1],
+        ["'", "'", "'", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "special_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["@", "@", "@", 1],    ["∑", "∑", "∑", 1],
+        ["€", "€", "€", 1],    ["®", "®", "®", 1],    ["†", "†", "†", 1],
+        ["Ω", "Ω", "Ω", 1],    ["¨", "¨", "¨", 1],    ["⁄", "⁄", "⁄", 1],
+        ["ø", "ø", "ø", 1],    ["π", "π", "π", 1],    ["•", "•", "•", 1],
+        ["±", "±", "±", 1],    ["\u23ce", null, "enter", 1.5]
+    ],
+    "special_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["æ", "æ", "æ", 1],    ["‚", "‚", "‚", 1],
+        ["∂", "∂", "∂", 1],    ["ƒ", "ƒ", "ƒ", 1],    ["©", "©", "©", 1],
+        ["ª", "ª", "ª", 1],    ["º", "º", "º", 1],    ["∆", "∆", "∆", 1],
+        ["@", "@", "@", 1],    ["œ", "œ", "œ", 1],    ["æ", "æ", "æ", 1],
+        ["‘", "‘", "‘", 1],    ["\u23ce", null, "enter", 1.2]
+    ],
+    "special_4": [
+        ["\u21e7", null, "shift", 1.5],  ["≤", "≤", "≤", 1],  ["¥", "¥", "¥", 1],
+        ["≈", "≈", "≈", 1],    ["ç", "ç", "ç", 1],    ["√", "√", "√", 1],
+        ["∫", "∫", "∫", 1],    ["~", "~", "~", 1],    ["µ", "µ", "µ", 1],
+        ["∞", "∞", "∞", 1],    ["…", "…", "…", 1],    ["–", "–", "–", 1],
+        ["\u21e7", null, "shift", 2.5]
+    ],
+    "special_5": [
+        ["@€¿", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ]
+}
diff --git a/kivy/data/keyboards/de_CH.json b/kivy/data/keyboards/de_CH.json
new file mode 100644
index 0000000..076a35a
--- /dev/null
+++ b/kivy/data/keyboards/de_CH.json
@@ -0,0 +1,98 @@
+{
+    "title": "de_CH",
+    "description": "A Swiss German keyboard, touch optimized (no shift+caps lock)",
+	"cols": 15,
+    "rows": 5,
+    "normal_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "normal_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["q", "q", "q", 1],    ["w", "w", "w", 1],
+        ["e", "e", "e", 1],    ["r", "r", "r", 1],    ["t", "t", "t", 1],
+        ["z", "z", "z", 1],    ["u", "u", "u", 1],    ["i", "i", "i", 1],
+        ["o", "o", "o", 1],    ["p", "p", "p", 1],    ["ü", "ü", "ü", 1],
+        [":", ":", ":", 1],    ["$", "$", "$", 1.5]
+    ],
+    "normal_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["a", "a", "a", 1],    ["s", "s", "s", 1],
+        ["d", "d", "d", 1],    ["f", "f", "f", 1],    ["g", "g", "g", 1],
+        ["h", "h", "h", 1],    ["j", "j", "j", 1],    ["k", "k", "k", 1],
+        ["l", "l", "l", 1],    ["ö", "ö", "ö", 1],    ["ä", "ä", "ä", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "normal_4": [
+        ["\u21e7", null, "shift", 2.5],  ["y", "y", "y", 1],    ["x", "x", "x", 1],
+        ["c", "c", "c", 1],    ["v", "v", "v", 1],    ["b", "b", "b", 1],
+        ["n", "n", "n", 1],    ["m", "m", "m", 1],    [",", ",", ",", 1],
+        [".", ".", ".", 1],    ["-", "-", "-", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "normal_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "shift_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "shift_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["Q", "Q", null, 1],    ["W", "W", null, 1],
+        ["E", "E", "e", 1],    ["R", "R", "r", 1],    ["T", "T", "t", 1],
+        ["Z", "Z", "z", 1],    ["U", "U", "u", 1],    ["I", "I", "i", 1],
+        ["O", "O", "o", 1],    ["P", "P", "p", 1],    ["Ü", "Ü", "Ü", 1],
+        [":", ":", ":", 1],    ["/", "/", "/", 1.5]
+    ],
+    "shift_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["A", "A", "a", 1],    ["S", "S", "s", 1],
+        ["D", "D", "d", 1],    ["F", "F", "f", 1],    ["G", "G", "g", 1],
+        ["H", "H", "h", 1],    ["J", "J", "j", 1],    ["K", "K", "k", 1],
+        ["L", "L", "l", 1],    ["Ö", "Ö", "Ö", 1],    ["Ä", "Ä", "Ä", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "shift_4": [
+        ["\u21e7", null, "shift", 2.5],  ["Y", "Y", "y", 1],  ["X", "X", "x", 1],
+        ["C", "C", "c", 1],    ["V", "V", "v", 1],    ["B", "B", "b", 1],
+        ["N", "N", "n", 1],    ["M", "M", "m", 1],    [";", ";", ";", 1],
+        [":", ":", ":", 1],    ["_", "_", "_", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "shift_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "special_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "special_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["(", "(", "(", 1],    [")", ")", ")", 1],
+        ["{", "{", "{", 1],    ["}", "}", "}", 1],    ["[", "[", "[", 1],
+        ["]", "]", "]", 1],    ["€", "€", "€", 1],    ["$", "$", "$", 1],
+        ["£", "£", "£", 1],    ["¥", "¥", "¥", 1],    ["è", "è", "è", 1],
+        ["•", "•", "•", 1],    ["|", "|", "|", 1.5]
+    ],
+    "special_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["“", "“", "“", 1],    ["`", "`", "`", 1],
+        ["«", "«", "«", 1],    ["»", "»", "»", 1],    ["#", "#", "#", 1],
+        ["%", "%", "%", 1],    ["^", "^", "^", 1],    ["°", "°", "°", 1],
+        ["&", "&", "&", 1],    ["é", "é", "é", 1],    ["à", "à", "à", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "special_4": [
+        ["\u21e7", null, "shift", 2.5],  ["+", "+", "+", 1],  ["=", "=", "=", 1],
+        ["<", "<", "<", 1],    [">", ">", ">", 1],    ["*", "*", "*", 1],
+        ["È", "È", "È", 1],    ["É", "É", "É", 1],    ["À", "À", "À", 1],
+        [":", ":", ":", 1],    ["_", "_", "_", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "special_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ]
+}
diff --git a/kivy/data/keyboards/en_US.json b/kivy/data/keyboards/en_US.json
new file mode 100644
index 0000000..630684e
--- /dev/null
+++ b/kivy/data/keyboards/en_US.json
@@ -0,0 +1,98 @@
+{
+    "title": "en_US",
+    "description": "A US Keyboard, touch optimized (no shift+caps lock)",
+	"cols": 15,
+    "rows": 5,
+    "normal_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "normal_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["q", "q", "q", 1],    ["w", "w", "w", 1],
+        ["e", "e", "e", 1],    ["r", "r", "r", 1],    ["t", "t", "t", 1],
+        ["y", "y", "y", 1],    ["u", "u", "u", 1],    ["i", "i", "i", 1],
+        ["o", "o", "o", 1],    ["p", "p", "p", 1],    ["[", "[", "[", 1],
+        ["]", "]", "]", 1],    ["\\", "\\", "\\", 1.5]
+    ],
+    "normal_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["a", "a", "a", 1],    ["s", "s", "s", 1],
+        ["d", "d", "d", 1],    ["f", "f", "f", 1],    ["g", "g", "g", 1],
+        ["h", "h", "h", 1],    ["j", "j", "j", 1],    ["k", "k", "k", 1],
+        ["l", "l", "l", 1],    [";", ";", ";", 1],    ["'", "'", "'", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "normal_4": [
+        ["\u21e7", null, "shift", 2.5],  ["z", "z", "z", 1],    ["x", "x", "x", 1],
+        ["c", "c", "c", 1],    ["v", "v", "v", 1],    ["b", "b", "b", 1],
+        ["n", "n", "n", 1],    ["m", "m", "m", 1],    [",", ",", ",", 1],
+        [".", ".", ".", 1],    ["/", "/", "/", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "normal_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "shift_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "shift_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["Q", "Q", null, 1],    ["W", "W", null, 1],
+        ["E", "E", "e", 1],    ["R", "R", "r", 1],    ["T", "T", "t", 1],
+        ["Y", "Y", "y", 1],    ["U", "U", "u", 1],    ["I", "I", "i", 1],
+        ["O", "O", "o", 1],    ["P", "P", "p", 1],    ["{", "{", "{", 1],
+        ["}", "}", "}", 1],    ["|", "|", "|", 1.5]
+    ],
+    "shift_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["A", "A", "a", 1],    ["S", "S", "s", 1],
+        ["D", "D", "d", 1],    ["F", "F", "f", 1],    ["G", "G", "g", 1],
+        ["H", "H", "h", 1],    ["J", "J", "j", 1],    ["K", "K", "k", 1],
+        ["L", "L", "l", 1],    [":", ":", ":", 1],    ["\"", "\"", "\"", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "shift_4": [
+        ["\u21e7", null, "shift", 2.5],  ["Z", "Z", "z", 1],  ["X", "X", "x", 1],
+        ["C", "C", "c", 1],    ["V", "V", "v", 1],    ["B", "B", "b", 1],
+        ["N", "N", "n", 1],    ["M", "M", "m", 1],    ["<", "<", "<", 1],
+        [">", ">", ">", 1],    ["?", "?", "?", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "shift_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "special_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "special_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["(", "(", "(", 1],    [")", ")", ")", 1],
+        ["{", "{", "{", 1],    ["}", "}", "}", 1],    ["[", "[", "[", 1],
+        ["]", "]", "]", 1],    ["€", "€", "€", 1],    ["$", "$", "$", 1],
+        ["£", "£", "£", 1],    ["¥", "¥", "¥", 1],    ["˘", "˘", "˘", 1],
+        ["•", "•", "•", 1],    ["|", "|", "|", 1.5]
+    ],
+    "special_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["“", "“", "“", 1],    ["`", "`", "`", 1],
+        ["«", "«", "«", 1],    ["»", "»", "»", 1],    ["#", "#", "#", 1],
+        ["%", "%", "%", 1],    ["^", "^", "^", 1],    ["°", "°", "°", 1],
+        ["&", "&", "&", 1],    ["ÿ", "ÿ", "ÿ", 1],    ["-", "-", "-", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "special_4": [
+        ["\u21e7", null, "shift", 2.5],  ["+", "+", "+", 1],  ["=", "=", "=", 1],
+        ["<", "<", "<", 1],    [">", ">", ">", 1],    ["*", "*", "*", 1],
+        ["Ù", "Ù", "Ù", 1],    ["~", "~", "~", 1],    ["À", "À", "À", 1],
+        [":", ":", ":", 1],    ["_", "_", "_", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "special_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ]
+}
diff --git a/kivy/data/keyboards/fr_CH.json b/kivy/data/keyboards/fr_CH.json
new file mode 100644
index 0000000..b158679
--- /dev/null
+++ b/kivy/data/keyboards/fr_CH.json
@@ -0,0 +1,98 @@
+{
+    "title": "fr_CH",
+    "description": "A Swiss French keyboard, touch optimized (no shift+caps lock)",
+	"cols": 15,
+    "rows": 5,
+    "normal_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "normal_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["q", "q", "q", 1],    ["w", "w", "w", 1],
+        ["e", "e", "e", 1],    ["r", "r", "r", 1],    ["t", "t", "t", 1],
+        ["z", "z", "z", 1],    ["u", "u", "u", 1],    ["i", "i", "i", 1],
+        ["o", "o", "o", 1],    ["p", "p", "p", 1],    ["è", "è", "è", 1],
+        [":", ":", ":", 1],    ["$", "$", "$", 1.5]
+    ],
+    "normal_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["a", "a", "a", 1],    ["s", "s", "s", 1],
+        ["d", "d", "d", 1],    ["f", "f", "f", 1],    ["g", "g", "g", 1],
+        ["h", "h", "h", 1],    ["j", "j", "j", 1],    ["k", "k", "k", 1],
+        ["l", "l", "l", 1],    ["é", "é", "é", 1],    ["à", "à", "à", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "normal_4": [
+        ["\u21e7", null, "shift", 2.5],  ["y", "y", "y", 1],    ["x", "x", "x", 1],
+        ["c", "c", "c", 1],    ["v", "v", "v", 1],    ["b", "b", "b", 1],
+        ["n", "n", "n", 1],    ["m", "m", "m", 1],    [",", ",", ",", 1],
+        [".", ".", ".", 1],    ["-", "-", "-", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "normal_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "shift_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "shift_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["Q", "Q", null, 1],    ["W", "W", null, 1],
+        ["E", "E", "e", 1],    ["R", "R", "r", 1],    ["T", "T", "t", 1],
+        ["Z", "Z", "z", 1],    ["U", "U", "u", 1],    ["I", "I", "i", 1],
+        ["O", "O", "o", 1],    ["P", "P", "p", 1],    ["È", "È", "È", 1],
+        [":", ":", ":", 1],    ["/", "/", "/", 1.5]
+    ],
+    "shift_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["A", "A", "a", 1],    ["S", "S", "s", 1],
+        ["D", "D", "d", 1],    ["F", "F", "f", 1],    ["G", "G", "g", 1],
+        ["H", "H", "h", 1],    ["J", "J", "j", 1],    ["K", "K", "k", 1],
+        ["L", "L", "l", 1],    ["É", "É", "É", 1],    ["À", "À", "À", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "shift_4": [
+        ["\u21e7", null, "shift", 2.5],  ["Y", "Y", "y", 1],  ["X", "X", "x", 1],
+        ["C", "C", "c", 1],    ["V", "V", "v", 1],    ["B", "B", "b", 1],
+        ["N", "N", "n", 1],    ["M", "M", "m", 1],    [";", ";", ";", 1],
+        [":", ":", ":", 1],    ["_", "_", "_", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "shift_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ],
+
+    "special_1": [
+        ["1", "1", "1", 1],    ["2", "2", "2", 1],    ["3", "3", "3", 1],
+        ["4", "4", "4", 1],    ["5", "5", "5", 1],    ["6", "6", "6", 1],
+        ["7", "7", "7", 1],    ["8", "8", "8", 1],    ["9", "9", "9", 1],
+        ["0", "0", "0", 1],    ["@", "@", "@", 1],    ["?", "?", "?", 1],
+        ["!", "!", "!", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "special_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["(", "(", "(", 1],    [")", ")", ")", 1],
+        ["{", "{", "{", 1],    ["}", "}", "}", 1],    ["[", "[", "[", 1],
+        ["]", "]", "]", 1],    ["€", "€", "€", 1],    ["$", "$", "$", 1],
+        ["£", "£", "£", 1],    ["¥", "¥", "¥", 1],    ["ü", "ü", "ü", 1],
+        ["•", "•", "•", 1],    ["|", "|", "|", 1.5]
+    ],
+    "special_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["“", "“", "“", 1],    ["`", "`", "`", 1],
+        ["«", "«", "«", 1],    ["»", "»", "»", 1],    ["#", "#", "#", 1],
+        ["%", "%", "%", 1],    ["^", "^", "^", 1],    ["°", "°", "°", 1],
+        ["&", "&", "&", 1],    ["ö", "ö", "ö", 1],    ["ä", "ä", "ä", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "special_4": [
+        ["\u21e7", null, "shift", 2.5],  ["+", "+", "+", 1],  ["=", "=", "=", 1],
+        ["<", "<", "<", 1],    [">", ">", ">", 1],    ["*", "*", "*", 1],
+        ["Ö", "Ö", "Ö", 1],    ["Ä", "Ä", "Ä", 1],    ["Ü", "Ü", "Ü", 1],
+        [":", ":", ":", 1],    ["_", "_", "_", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "special_5": [
+        ["#+=", null, "special", 2.5], [" ", " ", "spacebar", 11], ["\u2a2f", null, "escape", 1.5]
+    ]
+}
diff --git a/kivy/data/keyboards/qwerty.json b/kivy/data/keyboards/qwerty.json
new file mode 100644
index 0000000..d1dac3c
--- /dev/null
+++ b/kivy/data/keyboards/qwerty.json
@@ -0,0 +1,66 @@
+{
+    "title": "Qwerty",
+    "description": "A classical US Keyboard",
+	"cols": 15,
+    "rows": 5,
+    "normal_1": [
+        ["`", "`", "`", 1],    ["1", "1", "1", 1],    ["2", "2", "2", 1],
+        ["3", "3", "3", 1],    ["4", "4", "4", 1],    ["5", "5", "5", 1],
+        ["6", "6", "6", 1],    ["7", "7", "7", 1],    ["8", "8", "8", 1],
+        ["9", "9", "9", 1],    ["0", "0", "0", 1],    ["-", "-", "-", 1],
+        ["=", "=", "=", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "normal_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["q", "q", "q", 1],    ["w", "w", "w", 1],
+        ["e", "e", "e", 1],    ["r", "r", "r", 1],    ["t", "t", "t", 1],
+        ["y", "y", "y", 1],    ["u", "u", "u", 1],    ["i", "i", "i", 1],
+        ["o", "o", "o", 1],    ["p", "p", "p", 1],    ["[", "[", "[", 1],
+        ["]", "]", "j", 1],    ["\\", "\\", "\\", 1]
+    ],
+    "normal_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["a", "a", "a", 1],    ["s", "s", "s", 1],
+        ["d", "d", "d", 1],    ["f", "f", "f", 1],    ["g", "g", "g", 1],
+        ["h", "h", "h", 1],    ["j", "j", "j", 1],    ["k", "k", "k", 1],
+        ["l", "l", "l", 1],    [":", ":", ":", 1],    ["'", "'", "'", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "normal_4": [
+        ["\u21e7", null, "shift", 2.5],  ["z", "z", null, 1],    ["x", "x", "x", 1],
+        ["c", "c", "c", 1],    ["v", "v", "v", 1],    ["b", "b", "b", 1],
+        ["n", "n", "n", 1],    ["m", "m", "m", 1],    [",", ",", ",", 1],
+        [".", ".", ".", 1],    ["/", "/", "/", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "normal_5": [
+        [" ", " ", "spacebar", 12], ["\u2b12", null, "layout", 1.5], ["\u2a2f", null, "escape", 1.5]
+    ],
+    "shift_1": [
+        ["~", "~", "~", 1],    ["!", "!", "!", 1],    ["@", "@", "@", 1],
+        ["#", "#", "#", 1],    ["$", "$", "$", 1],    ["%", "%", "%", 1],
+        ["^", "^", null, 1],   ["&", "&", "&", 1],    ["*", "*", "*", 1],
+        ["(", "(", "(", 1],    [")", ")", ")", 1],    ["_", "_", "_", 1],
+        ["+", "+", "+", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "shift_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["Q", "Q", null, 1],    ["W", "W", null, 1],
+        ["E", "E", "e", 1],    ["R", "R", "r", 1],    ["T", "T", "t", 1],
+        ["Y", "Y", "y", 1],    ["U", "U", "u", 1],    ["I", "I", "i", 1],
+        ["O", "O", "o", 1],    ["P", "P", "p", 1],    ["{", "{", "{", 1],
+        ["}", "}", "}", 1],    ["|", "|", "|", 1.5]
+    ],
+    "shift_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["A", "A", "a", 1],    ["S", "S", "s", 1],
+        ["D", "D", "d", 1],    ["F", "F", "f", 1],    ["G", "G", "g", 1],
+        ["H", "H", "h", 1],    ["J", "J", "j", 1],    ["K", "K", "k", 1],
+        ["L", "L", "l", 1],    [";", ";", ";", 1],    ["\"", "\"", "\"", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "shift_4": [
+        ["\u21e7", null, "shift", 2.5],  ["Z", "Z", "z", 1],    ["X", "X", "x", 1],
+        ["C", "C", "c", 1],    ["V", "V", "v", 1],    ["B", "B", "b", 1],
+        ["N", "N", "n", 1],    ["M", "M", "m", 1],    ["<", "<", "<", 1],
+        [">", ">", ">", 1],    ["?", "?", "?", 1.5],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "shift_5": [
+        [" ", " ", "spacebar", 12], ["\u2b12", null, "layout", 1.5], ["\u2a2f", null, "escape", 1.5]
+    ]
+}
diff --git a/kivy/data/keyboards/qwertz.json b/kivy/data/keyboards/qwertz.json
new file mode 100644
index 0000000..c8ded5a
--- /dev/null
+++ b/kivy/data/keyboards/qwertz.json
@@ -0,0 +1,66 @@
+{
+    "title": "Qwerty",
+    "description": "A german Keyboard",
+	"cols": 15,
+    "rows": 5,
+    "normal_1": [
+        ["!", "!", "!", 1],    ["1", "1", "1", 1],    ["2", "2", "2", 1],
+        ["3", "3", "3", 1],    ["4", "4", "4", 1],    ["5", "5", "5", 1],
+        ["6", "6", "6", 1],    ["7", "7", "7", 1],    ["8", "8", "8", 1],
+        ["9", "9", "9", 1],    ["0", "0", "0", 1],    ["ß", "ß", "ß", 1],
+        ["?", "?", "?", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "normal_2" : [
+        ["\u21B9", "\t", "tab", 1.5],  ["q", "q", "q", 1],    ["w", "w", "w", 1],
+        ["e", "e", "e", 1],    ["r", "r", "r", 1],    ["t", "t", "t", 1],
+        ["z", "z", "z", 1],    ["u", "u", "u", 1],    ["i", "i", "i", 1],
+        ["o", "o", "o", 1],    ["p", "p", "p", 1],    ["ü", "ü", "ü", 1],
+        [":", ":", ":", 1],    ["/", "/", "/", 1]
+    ],
+    "normal_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["a", "a", "a", 1],    ["s", "s", "s", 1],
+        ["d", "d", "d", 1],    ["f", "f", "f", 1],    ["g", "g", "g", 1],
+        ["h", "h", "h", 1],    ["j", "j", "j", 1],    ["k", "k", "k", 1],
+        ["l", "l", "l", 1],    ["ö", "ö", "ö", 1],    ["ä", "ä", "ä", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "normal_4": [
+        ["\u21e7", null, "shift", 2.5],  ["y", "y", null, 1],    ["x", "x", "x", 1],
+        ["c", "c", "c", 1],    ["v", "v", "v", 1],    ["b", "b", "b", 1],
+        ["n", "n", "n", 1],    ["m", "m", "m", 1],    [",", ",", ",", 1],
+        [".", ".", ".", 1],    ["-", "-", "-", 1],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "normal_5": [
+        [" ", " ", "spacebar", 12], ["\u2b12", null, "layout", 1.5], ["\u2a2f", null, "escape", 1.5]
+    ],
+    "shift_1": [
+        ["\"", "\"", "\"", 1],    ["+", "+", "+", 1],    ["@", "@", "@", 1],
+        ["#", "#", "#", 1],    ["$", "$", "$", 1],    ["€", "€", "€", 1],
+        ["%", "%", "%", 1],   ["&", "&", "&", 1],    ["*", "*", "*", 1],
+        ["(", "(", "(", 1],    [")", ")", ")", 1],    ["<", "<", "<", 1],
+        [">", ">", ">", 1],    ["\u232b", null, "backspace", 2]
+    ],
+    "shift_2": [
+        ["\u21B9", "\t", "tab", 1.5],  ["Q", "Q", null, 1],    ["W", "W", null, 1],
+        ["E", "E", "e", 1],    ["R", "R", "r", 1],    ["T", "T", "t", 1],
+        ["Z", "Z", "z", 1],    ["U", "U", "u", 1],    ["I", "I", "i", 1],
+        ["O", "O", "o", 1],    ["P", "P", "p", 1],    ["{", "{", "{", 1],
+        ["}", "}", "}", 1],    ["|", "|", "|", 1.5]
+    ],
+    "shift_3": [
+        ["\u21ea", null, "capslock", 1.8],  ["A", "A", "a", 1],    ["S", "S", "s", 1],
+        ["D", "D", "d", 1],    ["F", "F", "f", 1],    ["G", "G", "g", 1],
+        ["H", "H", "h", 1],    ["J", "J", "j", 1],    ["K", "K", "k", 1],
+        ["L", "L", "l", 1],    ["=", "=", "=", 1],    ["°", "°", "°", 1],
+        ["\u23ce", null, "enter", 2.2]
+    ],
+    "shift_4": [
+        ["\u21e7", null, "shift", 2.5],  ["Y", "Y", "y", 1],    ["X", "X", "x", 1],
+        ["C", "C", "c", 1],    ["V", "V", "v", 1],    ["B", "B", "b", 1],
+        ["N", "N", "n", 1],    ["M", "M", "m", 1],    [";", ";", ";", 1],
+        [":", ":", ":", 1],    ["_", "_", "_", 1.5],    ["\u21e7", null, "shift", 2.5]
+    ],
+    "shift_5": [
+        [" ", " ", "spacebar", 12], ["\u2b12", null, "layout", 1.5], ["\u2a2f", null, "escape", 1.5]
+    ]
+}
diff --git a/kivy/data/logo/kivy-icon-128.png b/kivy/data/logo/kivy-icon-128.png
new file mode 100644
index 0000000..f51fa3f
Binary files /dev/null and b/kivy/data/logo/kivy-icon-128.png differ
diff --git a/kivy/data/logo/kivy-icon-16.png b/kivy/data/logo/kivy-icon-16.png
new file mode 100644
index 0000000..1c35ca2
Binary files /dev/null and b/kivy/data/logo/kivy-icon-16.png differ
diff --git a/kivy/data/logo/kivy-icon-24.png b/kivy/data/logo/kivy-icon-24.png
new file mode 100644
index 0000000..bc62449
Binary files /dev/null and b/kivy/data/logo/kivy-icon-24.png differ
diff --git a/kivy/data/logo/kivy-icon-256.png b/kivy/data/logo/kivy-icon-256.png
new file mode 100644
index 0000000..e5fc31a
Binary files /dev/null and b/kivy/data/logo/kivy-icon-256.png differ
diff --git a/kivy/data/logo/kivy-icon-32.png b/kivy/data/logo/kivy-icon-32.png
new file mode 100644
index 0000000..ced34d3
Binary files /dev/null and b/kivy/data/logo/kivy-icon-32.png differ
diff --git a/kivy/data/logo/kivy-icon-48.png b/kivy/data/logo/kivy-icon-48.png
new file mode 100644
index 0000000..bfe82a4
Binary files /dev/null and b/kivy/data/logo/kivy-icon-48.png differ
diff --git a/kivy/data/logo/kivy-icon-512.png b/kivy/data/logo/kivy-icon-512.png
new file mode 100644
index 0000000..1325da4
Binary files /dev/null and b/kivy/data/logo/kivy-icon-512.png differ
diff --git a/kivy/data/logo/kivy-icon-64.ico b/kivy/data/logo/kivy-icon-64.ico
new file mode 100644
index 0000000..98f36cd
Binary files /dev/null and b/kivy/data/logo/kivy-icon-64.ico differ
diff --git a/kivy/data/logo/kivy-icon-64.png b/kivy/data/logo/kivy-icon-64.png
new file mode 100644
index 0000000..b5571a4
Binary files /dev/null and b/kivy/data/logo/kivy-icon-64.png differ
diff --git a/kivy/data/settings_kivy.json b/kivy/data/settings_kivy.json
new file mode 100644
index 0000000..b76970f
--- /dev/null
+++ b/kivy/data/settings_kivy.json
@@ -0,0 +1,117 @@
+[
+	{
+		"type": "title",
+		"title": "Windows"
+	},
+	{
+		"type": "bool",
+		"title": "Fullscreen",
+		"desc": "Set the window in windowed or fullscreen",
+		"section": "graphics",
+		"key": "fullscreen",
+		"values": ["0", "auto"]
+	},
+	{
+		"type": "numeric",
+		"title": "FPS Limit",
+		"desc": "Maximum FPS limit if set, 0 for unlimited",
+		"section": "graphics",
+		"key": "maxfps"
+	},
+	{
+		"type": "bool",
+		"title": "Mouse cursor",
+		"desc": "Show/hide the mouse cursor on the window",
+		"section": "graphics",
+		"key": "show_cursor"
+	},
+    {
+        "type": "options",
+        "title": "Rotation",
+        "desc": "Rotation of the window",
+        "section": "graphics",
+        "key": "rotation",
+        "options": ["0", "90", "180", "270"]
+    },
+
+	{
+		"type": "title",
+		"title": "Logging"
+	},
+	{
+		"type": "bool",
+		"title": "File logging",
+		"desc": "If activated, the logging will be stored in a file",
+		"section": "kivy",
+		"key": "log_enable"
+	},
+	{
+		"type": "options",
+		"title": "Log level",
+		"desc": "Level of logging information",
+		"section": "kivy",
+		"key": "log_level",
+		"options": ["trace", "debug", "info", "warning", "error", "critical"]
+	},
+
+	{
+		"type": "title",
+		"title": "Keyboard"
+	},
+	{
+		"type": "options",
+		"title": "Keyboard mode",
+		"desc": "Activate the usage of Kivy Virtual Keyboard",
+		"section": "kivy",
+		"key": "keyboard_mode",
+		"options": ["system", "dock", "multi", "systemanddock", "systemandmulti"]
+	},
+	{
+		"type": "options",
+		"title": "Keyboard layout",
+		"desc": "Select a layout for virtual keyboard",
+		"section": "kivy",
+		"key": "keyboard_layout",
+		"options": ["qwerty", "azerty", "qwertz", "de_CH", "fr_CH", "en_US"]
+	},
+
+	{
+		"type": "title",
+		"title": "Input post-processing"
+	},
+	{
+		"type": "numeric",
+		"title": "Double tap distance",
+		"desc": "Radius in pixels within a double tap is detected",
+		"section": "postproc",
+		"key": "double_tap_distance"
+	},
+	{
+		"type": "numeric",
+		"title": "Double tap time",
+		"desc": "Time in milliseconds during a double tap is allowed",
+		"section": "postproc",
+		"key": "double_tap_time"
+	},
+	{
+		"type": "numeric",
+		"title": "Retain distance",
+		"desc": "Maximum distance to retain the touch",
+		"section": "postproc",
+		"key": "retain_distance"
+	},
+	{
+		"type": "numeric",
+		"title": "Retain time",
+		"desc": "Time in milliseconds during the touch will be retain",
+		"section": "postproc",
+		"key": "retain_distance"
+	},
+	{
+		"type": "numeric",
+		"title": "Jitter distance",
+		"desc": "Radius in pixels within the touch moves will be ignored",
+		"section": "postproc",
+		"key": "jitter_distance"
+	}
+]
diff --git a/kivy/data/style.kv b/kivy/data/style.kv
new file mode 100644
index 0000000..9e463d8
--- /dev/null
+++ b/kivy/data/style.kv
@@ -0,0 +1,1327 @@
+#:kivy 1.0
+
+<Label>:
+    canvas:
+        Color:
+            rgba: 1, 1, 1, 1
+        Rectangle:
+            texture: self.texture
+            size: self.texture_size
+            pos: int(self.center_x - self.texture_size[0] / 2.), int(self.center_y - self.texture_size[1] / 2.)
+
+<-Button,-ToggleButton>:
+    state_image: self.background_normal if self.state == 'normal' else self.background_down
+    disabled_image: self.background_disabled_normal if self.state == 'normal' else self.background_disabled_down
+    canvas:
+        Color:
+            rgba: self.background_color
+        BorderImage:
+            border: self.border
+            pos: self.pos
+            size: self.size
+            source: self.disabled_image if self.disabled else self.state_image
+        Color:
+            rgba: 1, 1, 1, 1
+        Rectangle:
+            texture: self.texture
+            size: self.texture_size
+            pos: int(self.center_x - self.texture_size[0] / 2.), int(self.center_y - self.texture_size[1] / 2.)
+
+<BubbleContent>
+    opacity: .7 if self.disabled else 1
+    rows: 1
+    canvas:
+        Color:
+            rgba: self.parent.background_color if self.parent else (1, 1, 1, 1)
+        BorderImage:
+            border: self.parent.border if self.parent else (16, 16, 16, 16)
+            texture: root.parent._bk_img.texture if root.parent else None
+            size: self.size
+            pos: self.pos
+            auto_scale: root.parent.border_auto_scale if self.parent else 'off'
+
+<BubbleButton>:
+    background_normal: 'atlas://data/images/defaulttheme/bubble_btn'
+    background_down: 'atlas://data/images/defaulttheme/bubble_btn_pressed'
+    background_disabled_normal: 'atlas://data/images/defaulttheme/bubble_btn'
+    background_disabled_down: 'atlas://data/images/defaulttheme/bubble_btn_pressed'
+    border: (0, 0, 0, 0)
+
+<Slider>:
+    canvas:
+        Color:
+            rgb: 1, 1, 1
+        BorderImage:
+            border: self.border_horizontal if self.orientation == 'horizontal' else self.border_vertical
+            pos: (self.x + self.padding, self.center_y - self.background_width / 2) if self.orientation == 'horizontal' else (self.center_x - self.background_width / 2, self.y + self.padding)
+            size: (self.width - self.padding * 2, self.background_width) if self.orientation == 'horizontal' else (self.background_width, self.height - self.padding * 2)
+            source: (self.background_disabled_horizontal if self.orientation == 'horizontal' else self.background_disabled_vertical) if self.disabled else (self.background_horizontal if self.orientation == 'horizontal' else self.background_vertical)
+        Color:
+            rgba: root.value_track_color if self.value_track and self.orientation == 'horizontal' else [1, 1, 1, 0]
+        Line:
+            width: self.value_track_width
+            points: self.x + self.padding, self.center_y, self.value_pos[0], self.center_y
+        Color:
+            rgba: root.value_track_color if self.value_track and self.orientation == 'vertical' else [1, 1, 1, 0]
+        Line:
+            width: self.value_track_width
+            points: self.center_x, self.y + self.padding, self.center_x, self.value_pos[1]
+        Color:
+            rgb: 1, 1, 1
+    Image:
+        pos: (root.value_pos[0] - root.cursor_width / 2, root.center_y - root.cursor_height / 2) if root.orientation == 'horizontal' else (root.center_x - root.cursor_width / 2, root.value_pos[1] - root.cursor_height / 2)
+        size: root.cursor_size
+        source: root.cursor_disabled_image if root.disabled else root.cursor_image
+        allow_stretch: True
+        keep_ratio: False
+
+<ProgressBar>:
+    canvas:
+        Color:
+            rgb: 1, 1, 1
+        BorderImage:
+            border: (12, 12, 12, 12)
+            pos: self.x, self.center_y - 12
+            size: self.width, 24
+            source: 'atlas://data/images/defaulttheme/progressbar_background'
+        BorderImage:
+            border: [int(min(self.width * (self.value / float(self.max)) if self.max else 0, 12))] * 4
+            pos: self.x, self.center_y - 12
+            size: self.width * (self.value / float(self.max)) if self.max else 0, 24
+            source: 'atlas://data/images/defaulttheme/progressbar'
+
+<SplitterStrip>:
+    border: self.parent.border if self.parent else (3, 3, 3, 3)
+    horizontal: '_h' if self.parent and self.parent.sizable_from[0] in  ('t', 'b') else ''
+    background_normal: 'atlas://data/images/defaulttheme/splitter{}{}'.format('_disabled' if self.disabled else '', self.horizontal)
+    background_down: 'atlas://data/images/defaulttheme/splitter_down{}{}'.format('_disabled' if self.disabled else '', self.horizontal)
+    Image:
+        pos: root.pos
+        size: root.size
+        allow_stretch: True
+        source: 'atlas://data/images/defaulttheme/splitter_grip' + root.horizontal
+
+<Scatter>:
+    canvas.before:
+        PushMatrix
+        MatrixInstruction:
+            matrix: self.transform
+    canvas.after:
+        PopMatrix
+
+
+<RelativeLayout>:
+    canvas.before:
+        PushMatrix
+        Translate:
+            xy: self.pos
+    canvas.after:
+        PopMatrix
+
+<Image,AsyncImage>:
+    canvas:
+        Color:
+            rgba: self.color
+        Rectangle:
+            texture: self.texture
+            size: self.norm_image_size
+            pos: self.center_x - self.norm_image_size[0] / 2., self.center_y - self.norm_image_size[1] / 2.
+
+<EffectWidget>:
+    canvas.before:
+        Translate:
+            xy: -self.x, -self.y
+    canvas:
+        Color:
+            rgba: 1, 1, 1, 1
+        Rectangle:
+            texture: self.texture
+            pos: self.pos
+            size: self.size
+
+<TabbedPanelContent>
+    rows: 1
+    padding: 3
+    canvas:
+        Color:
+            rgba: self.parent.background_color if self.parent else (1, 1, 1, 1)
+        BorderImage:
+            border: self.parent.border if self.parent else (16, 16, 16, 16)
+            source: (root.parent.background_disabled_image if self.disabled else root.parent.background_image) if root.parent else None
+            size: self.size
+            pos: self.pos
+
+<TabbedPanelStrip>
+    rows: 1
+
+<StripLayout>
+    padding: '2dp', '2dp', '2dp', '2dp'
+    canvas.before:
+        BorderImage:
+            pos: self.pos
+            size: self.size
+            border: root.border
+            source: root.background_image
+
+<TabbedPanelHeader>:
+    halign: 'center'
+    valign: 'middle'
+    background_normal: 'atlas://data/images/defaulttheme/tab_btn'
+    background_disabled_normal: 'atlas://data/images/defaulttheme/tab_btn_disabled'
+    background_down: 'atlas://data/images/defaulttheme/tab_btn_pressed'
+    background_disabled_down: 'atlas://data/images/defaulttheme/tab_btn_pressed'
+    border: (8, 8, 8, 8)
+    font_size: '15sp'
+
+<Selector>
+    color: 148. / 255, 208 / 255., 230 / 255., 1
+    allow_stretch: True
+
+<TextInput>:
+    canvas.before:
+        Color:
+            rgba: self.background_color
+        BorderImage:
+            border: self.border
+            pos: self.pos
+            size: self.size
+            source: self.background_active if self.focus else (self.background_disabled_normal if self.disabled else self.background_normal)
+        Color:
+            rgba:
+                (self.cursor_color
+                if self.focus and not self._cursor_blink
+                and int(self.x + self.padding[0]) <= self._cursor_visual_pos[0] <= int(self.x + self.width - self.padding[2])
+                else (0, 0, 0, 0))
+        Rectangle:
+            pos: self._cursor_visual_pos
+            size: root.cursor_width, -self._cursor_visual_height
+        Color:
+            rgba: self.disabled_foreground_color if self.disabled else (self.hint_text_color if not self.text else self.foreground_color)
+
+<TextInputCutCopyPaste>:
+    but_cut: cut.__self__
+    but_copy: copy.__self__
+    but_paste: paste.__self__
+    but_selectall: selectall.__self__
+
+    size_hint: None, None
+    size: '150sp', '50sp'
+    BubbleButton:
+        id: cut
+        text: 'Cut'
+        on_release: root.do('cut')
+    BubbleButton:
+        id: copy
+        text: 'Copy'
+        on_release: root.do('copy')
+    BubbleButton:
+        id: paste
+        text: 'Paste'
+        on_release: root.do('paste')
+    BubbleButton:
+        id: selectall
+        text: 'Select All'
+        on_release: root.do('selectall')
+
+<CodeInput>:
+    font_name: 'data/fonts/RobotoMono-Regular.ttf'
+
+
+<TreeViewNode>:
+    canvas.before:
+        Color:
+            rgba: self.color_selected if self.is_selected else self.odd_color if self.odd else self.even_color
+        Rectangle:
+            pos: [self.parent.x, self.y] if self.parent else [0, 0]
+            size: [self.parent.width, self.height] if self.parent else [1, 1]
+        Color:
+            rgba: 1, 1, 1, int(not self.is_leaf)
+        Rectangle:
+            source: 'atlas://data/images/defaulttheme/tree_%s' % ('opened' if self.is_open else 'closed')
+            size: self.height / (3. if dp(1) > 1 else 2.), self.height / (3. if dp(1) > 1 else 2.)
+            pos: self.x - dp(20), int(self.center_y - (self.height / (3. if dp(1) > 1 else 2.)) * .5)
+    canvas.after:
+        Color:
+            rgba: .5, .5, .5, .2
+        Line:
+            points: [self.parent.x, self.y, self.parent.right, self.y] if self.parent else []
+
+
+<TreeViewLabel>:
+    width: self.texture_size[0]
+    height: max(self.texture_size[1] + dp(10), dp(24))
+    text_size: self.width, None
+
+
+<StencilView>:
+    canvas.before:
+        StencilPush
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        StencilUse
+
+    canvas.after:
+        StencilUnUse
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        StencilPop
+
+
+<FileChooserListLayout>:
+    on_entry_added: treeview.add_node(args[1])
+    on_entries_cleared: treeview.root.nodes = []
+    on_subentry_to_entry: not args[2].locked and treeview.add_node(args[1], args[2])
+    on_remove_subentry: args[2].nodes = []
+    BoxLayout:
+        pos: root.pos
+        size: root.size
+        size_hint: None, None
+        orientation: 'vertical'
+        BoxLayout:
+            size_hint_y: None
+            height: '30dp'
+            orientation: 'horizontal'
+            Widget:
+                # Just for spacing
+                width: '10dp'
+                size_hint_x: None
+            Label:
+                text: 'Name'
+                text_size: self.size
+                halign: 'left'
+                bold: True
+            Label:
+                text: 'Size'
+                text_size: self.size
+                size_hint_x: None
+                halign: 'right'
+                bold: True
+            Widget:
+                # Just for spacing
+                width: '10dp'
+                size_hint_x: None
+        ScrollView:
+            id: scrollview
+            do_scroll_x: False
+            Scatter:
+                do_rotation: False
+                do_scale: False
+                do_translation: False
+                size: treeview.size
+                size_hint_y: None
+                TreeView:
+                    id: treeview
+                    hide_root: True
+                    size_hint_y: None
+                    width: scrollview.width
+                    height: self.minimum_height
+                    on_node_expand: root.controller.entry_subselect(args[1])
+                    on_node_collapse: root.controller.close_subselection(args[1])
+
+<FileChooserListView>:
+    layout: layout
+    FileChooserListLayout:
+        id: layout
+        controller: root
+
+[FileListEntry@FloatLayout+TreeViewNode]:
+    locked: False
+    entries: []
+    path: ctx.path
+    # FIXME: is_selected is actually a read_only treeview property. In this
+    # case, however, we're doing this because treeview only has single-selection
+    # hardcoded in it. The fix to this would be to update treeview to allow
+    # multiple selection.
+    is_selected: self.path in ctx.controller().selection
+
+    orientation: 'horizontal'
+    size_hint_y: None
+    height: '48dp' if dp(1) > 1 else '24dp'
+    # Don't allow expansion of the ../ node
+    is_leaf: not ctx.isdir or ctx.name.endswith('..' + ctx.sep) or self.locked
+    on_touch_down: self.collide_point(*args[1].pos) and ctx.controller().entry_touched(self, args[1])
+    on_touch_up: self.collide_point(*args[1].pos) and ctx.controller().entry_released(self, args[1])
+    BoxLayout:
+        pos: root.pos
+        size_hint_x: None
+        width: root.width - dp(10)
+        Label:
+            id: filename
+            text_size: self.width, None
+            halign: 'left'
+            shorten: True
+            text: ctx.name
+            font_name: ctx.controller().font_name
+        Label:
+            text_size: self.width, None
+            size_hint_x: None
+            halign: 'right'
+            text: '{}'.format(ctx.get_nice_size())
+            font_name: ctx.controller().font_name
+
+<FileChooserIconLayout>:
+    on_entry_added: stacklayout.add_widget(args[1])
+    on_entries_cleared: stacklayout.clear_widgets()
+    ScrollView:
+        id: scrollview
+        pos: root.pos
+        size: root.size
+        size_hint: None, None
+        do_scroll_x: False
+        Scatter:
+            do_rotation: False
+            do_scale: False
+            do_translation: False
+            size_hint_y: None
+            height: stacklayout.height
+            StackLayout:
+                id: stacklayout
+                width: scrollview.width
+                size_hint_y: None
+                height: self.minimum_height
+                spacing: '10dp'
+                padding: '10dp'
+
+<FileChooserIconView>:
+    layout: layout
+    FileChooserIconLayout:
+        id: layout
+        controller: root
+
+[FileIconEntry@Widget]:
+    locked: False
+    path: ctx.path
+    selected: self.path in ctx.controller().selection
+    size_hint: None, None
+
+    on_touch_down: self.collide_point(*args[1].pos) and ctx.controller().entry_touched(self, args[1])
+    on_touch_up: self.collide_point(*args[1].pos) and ctx.controller().entry_released(self, args[1])
+    size: '100dp', '100dp'
+
+    canvas:
+        Color:
+            rgba: 1, 1, 1, 1 if self.selected else 0
+        BorderImage:
+            border: 8, 8, 8, 8
+            pos: root.pos
+            size: root.size
+            source: 'atlas://data/images/defaulttheme/filechooser_selected'
+
+    Image:
+        size: '48dp', '48dp'
+        source: 'atlas://data/images/defaulttheme/filechooser_%s' % ('folder' if ctx.isdir else 'file')
+        pos: root.x + dp(24), root.y + dp(40)
+    Label:
+        text: ctx.name
+        font_name: ctx.controller().font_name
+        text_size: (root.width, self.height)
+        halign: 'center'
+        shorten: True
+        size: '100dp', '16dp'
+        pos: root.x, root.y + dp(16)
+    Label:
+        text: '{}'.format(ctx.get_nice_size())
+        font_name: ctx.controller().font_name
+        font_size: '11sp'
+        color: .8, .8, .8, 1
+        size: '100dp', '16sp'
+        pos: root.pos
+        halign: 'center'
+
+<FileChooserProgress>:
+    pos_hint: {'x': 0, 'y': 0}
+    canvas:
+        Color:
+            rgba: 0, 0, 0, .8
+        Rectangle:
+            pos: self.pos
+            size: self.size
+    Label:
+        pos_hint: {'x': .2, 'y': .6}
+        size_hint: .6, .2
+        text: 'Opening %s' % root.path
+        text_size: self.size
+        halign: 'center'
+        valign: 'middle'
+    FloatLayout:
+        pos_hint: {'x': .2, 'y': .4}
+        size_hint: .6, .2
+        ProgressBar:
+            id: pb
+            pos_hint: {'x': 0, 'center_y': .5}
+            max: root.total
+            value: root.index
+        Label:
+            pos_hint: {'x': 0}
+            text: '%d / %d' % (root.index, root.total)
+            size_hint_y: None
+            height: self.texture_size[1]
+            y: pb.center_y - self.height - 8
+            font_size: '13sp'
+            color: (.8, .8, .8, .8)
+
+    AnchorLayout:
+        pos_hint: {'x': .2, 'y': .2}
+        size_hint: .6, .2
+
+        Button:
+            text: 'Cancel'
+            size_hint: None, None
+            size: 150, 44
+            on_release: root.cancel()
+
+
+
+# Switch widget
+<Switch>:
+    active_norm_pos: max(0., min(1., (int(self.active) + self.touch_distance / sp(41))))
+    canvas:
+        Color:
+            rgb: 1, 1, 1
+        Rectangle:
+            source: 'atlas://data/images/defaulttheme/switch-background{}'.format('_disabled' if self.disabled else '')
+            size: sp(83), sp(32)
+            pos: int(self.center_x - sp(41)), int(self.center_y - sp(16))
+    canvas.after:
+        Color:
+            rgb: 1, 1, 1
+        Rectangle:
+            source: 'atlas://data/images/defaulttheme/switch-button{}'.format('_disabled' if self.disabled else '')
+            size: sp(43), sp(32)
+            pos: int(self.center_x - sp(41) + self.active_norm_pos * sp(41)), int(self.center_y - sp(16))
+
+
+# ModalView widget
+<ModalView>:
+    canvas:
+        Color:
+            rgba: root.overlay_color[:3] + [root.overlay_color[-1] * self._anim_alpha]
+        Rectangle:
+            size: self._window.size if self._window else (0, 0)
+
+        Color:
+            rgba: root.background_color
+        BorderImage:
+            source: root.background
+            border: root.border
+            pos: self.pos
+            size: self.size
+
+
+# Popup widget
+<Popup>:
+    _container: container
+    GridLayout:
+        padding: '12dp'
+        cols: 1
+        size_hint: None, None
+        pos: root.pos
+        size: root.size
+
+        Label:
+            text: root.title
+            color: root.title_color
+            size_hint_y: None
+            height: self.texture_size[1] + dp(16)
+            text_size: self.width - dp(16), None
+            font_size: root.title_size
+            font_name: root.title_font
+            halign: root.title_align
+
+        Widget:
+            size_hint_y: None
+            height: dp(4)
+            canvas:
+                Color:
+                    rgba: root.separator_color
+                Rectangle:
+                    pos: self.x, self.y + root.separator_height / 2.
+                    size: self.width, root.separator_height
+
+        BoxLayout:
+            id: container
+
+# =============================================================================
+# Spinner widget
+# =============================================================================
+
+<SpinnerOption>:
+    size_hint_y: None
+    height: '48dp'
+
+<Spinner>:
+    background_normal: 'atlas://data/images/defaulttheme/spinner'
+    background_disabled_normal: 'atlas://data/images/defaulttheme/spinner_disabled'
+    background_down: 'atlas://data/images/defaulttheme/spinner_pressed'
+
+# =============================================================================
+# ActionBar widget
+# =============================================================================
+
+<ActionBar>:
+    height: '48dp'
+    size_hint_y: None
+    spacing: '4dp'
+    canvas:
+        Color:
+            rgba: self.background_color
+        BorderImage:
+            border: root.border
+            pos: self.pos
+            size: self.size
+            source: self.background_image
+
+<ActionView>:
+    orientation: 'horizontal'
+    canvas:
+        Color:
+            rgba: self.background_color
+        BorderImage:
+            pos: self.pos
+            size: self.size
+            source: self.background_image
+
+<ActionSeparator>:
+    size_hint_x: None
+    minimum_width: '2sp'
+    width: self.minimum_width
+    canvas:
+        Rectangle:
+            pos: self.x, self.y + sp(4)
+            size: self.width, self.height - sp(8)
+            source: self.background_image
+
+<ActionButton,ActionToggleButton>:
+    background_normal: 'atlas://data/images/defaulttheme/' + ('action_bar' if self.inside_group else 'action_item')
+    background_down: 'atlas://data/images/defaulttheme/action_item_down'
+    size_hint_x: None if not root.inside_group else 1
+    width: [dp(48) if (root.icon and not root.inside_group) else max(dp(48), (self.texture_size[0] + dp(32))), self.size_hint_x][0]
+    color: self.color[:3] + [0 if (root.icon and not root.inside_group) else 1]
+
+    Image:
+        allow_stretch: True
+        opacity: 1 if (root.icon and not root.inside_group) else 0
+        source: root.icon
+        mipmap: root.mipmap
+        pos: root.x + dp(4), root.y + dp(4)
+        size: root.width - dp(8), root.height - sp(8)
+
+<ActionLabel>:
+    size_hint_x: None if not root.inside_group else 1
+    width: self.texture_size[0] + dp(32)
+
+<ActionGroup>:
+    size_hint_x: None
+    width: self.texture_size[0] + dp(32)
+
+<ActionCheck>:
+    background_normal: 'atlas://data/images/defaulttheme/action_bar' if self.inside_group else 'atlas://data/images/defaulttheme/action_item'
+
+<ActionPreviousImage@Image>:
+    temp_width: 0
+    temp_height: 0
+
+<ActionPreviousButton@Button>:
+    background_normal: 'atlas://data/images/defaulttheme/action_item'
+    background_down: 'atlas://data/images/defaulttheme/action_item_down'
+
+<ActionPrevious>:
+    size_hint_x: 1
+    minimum_width: layout.minimum_width + min(sp(100), title.width)
+    important: True
+    GridLayout:
+        id: layout
+        rows: 1
+        pos: root.pos
+        size_hint_x: None
+        width: self.minimum_width
+        ActionPreviousButton:
+            on_press: root.dispatch('on_press')
+            on_release: root.dispatch('on_release')
+            size_hint_x: None
+            width: prevlayout.width
+            GridLayout:
+                id: prevlayout
+                rows: 1
+                width: self.minimum_width
+                height: self.parent.height
+                pos: self.parent.pos
+                ActionPreviousImage:
+                    id: prev_icon_image
+                    source: root.previous_image
+                    opacity: 1 if root.with_previous else 0
+                    allow_stretch: True
+                    size_hint_x: None
+                    temp_width: root.previous_image_width or dp(prev_icon_image.texture_size[0])
+                    temp_height: root.previous_image_height or dp(prev_icon_image.texture_size[1])
+                    width:
+                        (self.temp_width if self.temp_height <= self.height else \
+                        self.temp_width * (self.height / self.temp_height)) \
+                        if self.texture else dp(8)
+                    mipmap: root.mipmap
+                ActionPreviousImage:
+                    id: app_icon_image
+                    source: root.app_icon
+                    allow_stretch: True
+                    size_hint_x: None
+                    temp_width: root.app_icon_width or dp(app_icon_image.texture_size[0])
+                    temp_height: root.app_icon_height or dp(app_icon_image.texture_size[1])
+                    width:
+                        (self.temp_width if self.temp_height <= self.height else \
+                        self.temp_width * (self.height / self.temp_height)) \
+                        if self.texture and root.app_icon else 0
+                    mipmap: root.mipmap
+                Widget:
+                    size_hint_x: None
+                    width: '5sp'
+    Label:
+        id: title
+        text: root.title
+        text_size: self.size
+        color: root.color
+        markup: root.markup
+        shorten: True
+        shorten_from: 'right'
+        halign: 'left'
+        valign: 'middle'
+
+<ActionGroup>:
+    background_normal: 'atlas://data/images/defaulttheme/action_group'
+    background_down: 'atlas://data/images/defaulttheme/action_group_down'
+    background_disabled_normal: 'atlas://data/images/defaulttheme/action_group_disabled'
+    border: 30, 30, 3, 3
+    ActionSeparator:
+        pos: root.pos
+        size: root.separator_width, root.height
+        opacity: 1 if root.use_separator else 0
+        background_image: root.separator_image if root.use_separator else 'action_view'
+
+<ActionOverflow>:
+    border: 3, 3, 3, 3
+    background_normal: 'atlas://data/images/defaulttheme/action_item'
+    background_down: 'atlas://data/images/defaulttheme/action_item_down'
+    background_disabled_normal: 'atlas://data/images/defaulttheme/button_disabled'
+    size_hint_x: None
+    minimum_width: '48sp'
+    width: self.texture_size[0] if self.texture else self.minimum_width
+    canvas.after:
+        Color:
+            rgb: 1, 1, 1
+        Rectangle:
+            pos: root.center_x - sp(16), root.center_y - sp(16)
+            size: sp(32), sp(32)
+            source: root.overflow_image
+
+<ActionDropDown>:
+    auto_width: False
+
+
+# =============================================================================
+# Accordion widget
+# =============================================================================
+
+[AccordionItemTitle@Label]:
+    text: ctx.title
+    normal_background: ctx.item.background_normal if ctx.item.collapse else ctx.item.background_selected
+    disabled_background: ctx.item.background_disabled_normal if ctx.item.collapse else ctx.item.background_disabled_selected
+    canvas.before:
+        Color:
+            rgba: self.disabled_color if self.disabled else self.color
+        BorderImage:
+            source: self.disabled_background if self.disabled else self.normal_background
+            pos: self.pos
+            size: self.size
+        PushMatrix
+        Translate:
+            xy: self.center_x, self.center_y
+        Rotate:
+            angle: 90 if ctx.item.orientation == 'horizontal' else 0
+            axis: 0, 0, 1
+        Translate:
+            xy: -self.center_x, -self.center_y
+    canvas.after:
+        PopMatrix
+
+
+<AccordionItem>:
+    container: container
+    container_title: container_title
+
+    BoxLayout:
+        orientation: root.orientation
+        pos: root.pos
+        BoxLayout:
+            size_hint_x: None if root.orientation == 'horizontal' else 1
+            size_hint_y: None if root.orientation == 'vertical' else 1
+            width: root.min_space if root.orientation == 'horizontal' else 100
+            height: root.min_space if root.orientation == 'vertical' else 100
+            id: container_title
+
+        StencilView:
+            id: sv
+
+            BoxLayout:
+                id: container
+                pos: sv.pos
+                size: root.content_size
+
+
+# =============================================================================
+# Settings
+# =============================================================================
+
+<SettingSpacer>:
+    size_hint_y: None
+    height: 5
+    canvas:
+        Color:
+            rgb: .2, .2, .2
+        Rectangle:
+            pos: self.x, self.center_y
+            size: self.width, 1
+
+<SettingItem>:
+    size_hint: .25, None
+    height: labellayout.texture_size[1] + dp(10)
+    content: content
+    canvas:
+        Color:
+            rgba: 47 / 255., 167 / 255., 212 / 255., self.selected_alpha
+        Rectangle:
+            pos: self.x, self.y + 1
+            size: self.size
+        Color:
+            rgb: .2, .2, .2
+        Rectangle:
+            pos: self.x, self.y - 2
+            size: self.width, 1
+
+    BoxLayout:
+        pos: root.pos
+
+        Label:
+            size_hint_x: .66
+            id: labellayout
+            markup: True
+            text: u'{0}\n[size=13sp][color=999999]{1}[/color][/size]'.format(root.title or '', root.desc or '')
+            font_size: '15sp'
+            text_size: self.width - 32, None
+
+        BoxLayout:
+            id: content
+            size_hint_x: .33
+
+
+<SettingBoolean>:
+    Switch:
+        text: 'Boolean'
+        pos: root.pos
+        active: bool(root.values.index(root.value)) if root.value in root.values else False
+        on_active: root.value = root.values[int(args[1])]
+
+<SettingString>:
+    Label:
+        text: root.value or ''
+        pos: root.pos
+        font_size: '15sp'
+
+<SettingPath>:
+    Label:
+        text: root.value or ''
+        pos: root.pos
+        font_size: '15sp'
+
+#:import kivy kivy
+<SettingColor>:
+    BoxLayout:
+        Label:
+            size_hint_x: None
+            width: 44
+            padding: (0, 5)
+            canvas.before:
+                # white border to see that there's a color tile at dark colors e.g. black
+                Color:
+                    rgba: (1,1,1,1.)
+                Line:
+                    rectangle: self.x,self.y,self.width,self.height
+                Color: 
+                    rgba: kivy.utils.get_color_from_hex(root.value) if root.value else (1,1,1,1.)
+                Rectangle:
+                    pos: self.pos
+                    size: self.size 
+        
+        Label:
+            text: root.value or ''
+            pos: root.pos
+            font_size: '15sp'
+            text_size: self.size
+            valign: 'middle'
+            halign: 'center'
+            padding: (5,0)
+
+<SettingOptions>:
+    Label:
+        text: root.value or ''
+        pos: root.pos
+        font_size: '15sp'
+
+<SettingTitle>:
+    text_size: self.width - 32, None
+    size_hint_y: None
+    height: max(dp(20), self.texture_size[1] + dp(20))
+    color: (.9, .9, .9, 1)
+    font_size: '15sp'
+    canvas:
+        Color:
+            rgba: .15, .15, .15, .5
+        Rectangle:
+            pos: self.x, self.y + 2
+            size: self.width, self.height - 2
+        Color:
+            rgb: .2, .2, .2
+        Rectangle:
+            pos: self.x, self.y - 2
+            size: self.width, 1
+
+<SettingSidebarLabel>:
+    size_hint: 1, None
+    text_size: self.width - 32, None
+    height: self.texture_size[1] + dp(20)
+    font_size: '15sp'
+    canvas.before:
+        Color:
+            rgba: 47 / 255., 167 / 255., 212 / 255., int(self.selected)
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+<SettingsPanel>:
+    spacing: 5
+    padding: 5
+    size_hint_y: None
+    height: self.minimum_height
+
+    Label:
+        size_hint_y: None
+        text: root.title
+        text_size: self.width - 32, None
+        height: max(50, self.texture_size[1] + 20)
+        color: (.5, .5, .5, 1)
+        font_size: '15sp'
+
+        canvas.after:
+            Color:
+                rgb: .2, .2, .2
+            Rectangle:
+                pos: self.x, self.y - 2
+                size: self.width, 1
+
+<Settings>:
+    orientation: 'horizontal'
+    canvas.before:
+        Color:
+            rgb: 0, 0, 0
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+<InterfaceWithSidebar>:
+    orientation: 'horizontal'
+    menu: menu
+    content: content
+    MenuSidebar:
+        id: menu
+    ContentPanel:
+        id: content
+        current_uid: menu.selected_uid
+
+<InterfaceWithSpinner>:
+    orientation: 'vertical'
+    menu: menu
+    content: content
+    MenuSpinner:
+        id: menu
+    ContentPanel:
+        id: content
+        current_uid: menu.selected_uid
+
+<MenuSpinner>:
+    orientation: 'horizontal'
+    size_hint_y: None
+    height: '50dp'
+    spinner: spinner
+    spinner_text: spinner.text
+    close_button: button
+    Spinner:
+        id: spinner
+    Button:
+        text: 'Close'
+        id: button
+        size_hint_x: None
+        width: min(dp(200), 0.4*root.width)
+        font_size: '15sp'
+
+
+<MenuSidebar>:
+    size_hint_x: None
+    width: '200dp'
+    buttons_layout: menu
+    close_button: button
+    GridLayout:
+        pos: root.pos
+        cols: 1
+        id: menu
+        padding: 5
+
+        canvas.after:
+            Color:
+                rgb: .2, .2, .2
+            Rectangle:
+                pos: self.right - 1, self.y
+                size: 1, self.height
+
+    Button:
+        text: 'Close'
+        id: button
+        size_hint: None, None
+        width: root.width - dp(20)
+        height: max(50, self.texture_size[1] + dp(20))
+        pos: root.x + dp(10), root.y + dp(10)
+        font_size: '15sp'
+
+<ContentPanel>:
+    do_scroll_x: False
+    container: content
+    GridLayout:
+        id: content
+        cols: 1
+        size_hint_y: None
+        height: self.minimum_height
+
+<InterfaceWithTabbedPanel>:
+    tabbedpanel: tp
+    close_button: button
+    TabbedPanel:
+        id: tp
+        size: root.size
+        pos: root.pos
+        #do_default_tab: False
+        background_color: (0,0,0,1)
+    Button:
+        id: button
+        text: 'Close'
+        size_hint: None, None
+        height: '45dp'
+        width: min(dp(200), 0.3*root.width)
+        x: root.x + root.width - self.width
+        y: root.y + root.height - self.height
+
+<ScrollView>:
+    _handle_y_pos: (self.right - self.bar_width - self.bar_margin) if self.bar_pos_y == 'right' else (self.x + self.bar_margin), self.y + self.height * self.vbar[0]
+    _handle_y_size: min(self.bar_width, self.width), self.height * self.vbar[1]
+    _handle_x_pos: self.x + self.width * self.hbar[0], (self.y + self.bar_margin) if self.bar_pos_x == 'bottom' else (self.top - self.bar_margin - self.bar_width)
+    _handle_x_size: self.width * self.hbar[1], min(self.bar_width, self.height)
+    canvas.after:
+        Color:
+            rgba: self._bar_color if (self.do_scroll_y and self.viewport_size[1] > self.height) else [0, 0, 0, 0]
+        Rectangle:
+            pos: root._handle_y_pos or (0, 0)
+            size: root._handle_y_size or (0, 0)
+        Color:
+            rgba: self._bar_color if (self.do_scroll_x and self.viewport_size[0] > self.width) else [0, 0, 0, 0]
+        Rectangle:
+            pos: root._handle_x_pos or (0, 0)
+            size: root._handle_x_size or (0, 0)
+
+# =============================================================================
+# Video player
+# =============================================================================
+
+<VideoPlayerPreview>:
+    pos_hint: {'x': 0, 'y': 0}
+    image_overlay_play: 'atlas://data/images/defaulttheme/player-play-overlay'
+    image_loading: 'data/images/image-loading.zip'
+    Image:
+        source: root.source
+        color: (.5, .5, .5, 1) if root.source else (0, 0, 0, 0)
+        pos_hint: {'x': 0, 'y': 0}
+    Image:
+        source: root.image_overlay_play if not root.click_done else root.image_loading
+        pos_hint: {'x': 0, 'y': 0}
+
+
+<VideoPlayerAnnotation>:
+    canvas.before:
+        Color:
+            rgba: self.annotation['bgcolor'] if 'bgcolor' in self.annotation else (0, 0, 0, 0.8)
+        BorderImage:
+            pos: self.pos
+            size: self.size
+            source: self.annotation['bgsource'] if 'bgsource' in self.annotation else None
+            border: self.annotation['border'] if 'border' in self.annotation else (0, 0, 0, 0)
+    size_hint: self.annotation['size_hint'] if 'size_hint' in self.annotation else (None, None)
+    size: self.annotation['size'] if 'size' in self.annotation else (self.texture_size[0] + 20, self.texture_size[1] + 20)
+    pos_hint: self.annotation['pos_hint'] if 'pos_hint' in self.annotation else {'center_x': .5, 'y': .05}
+
+<VideoPlayer>:
+    container: container
+    cols: 1
+
+    FloatLayout:
+        cols: 1
+        id: container
+
+    GridLayout:
+        rows: 1
+        size_hint_y: None
+        height: '44dp'
+
+        VideoPlayerStop:
+            size_hint_x: None
+            video: root
+            width: '44dp'
+            source: root.image_stop
+            allow_stretch: True
+
+        VideoPlayerPlayPause:
+            size_hint_x: None
+            video: root
+            width: '44dp'
+            source: root.image_pause if root.state == 'play' else root.image_play
+            allow_stretch: True
+
+        VideoPlayerVolume:
+            video: root
+            size_hint_x: None
+            width: '44dp'
+            source: root.image_volumehigh if root.volume > 0.8 else (root.image_volumemedium if root.volume > 0.4 else (root.image_volumelow if root.volume > 0 else root.image_volumemuted))
+            allow_stretch: True
+
+        Widget:
+            size_hint_x: None
+            width: 5
+
+        VideoPlayerProgressBar:
+            video: root
+            max: max(root.duration, root.position, 1)
+            value: root.position
+
+        Widget:
+            size_hint_x: None
+            width: 10
+
+# =============================================================================
+# Checkbox
+# =============================================================================
+
+<CheckBox>:
+    _checkbox_state_image:
+        self.background_checkbox_down \
+        if self.active else self.background_checkbox_normal
+    _checkbox_disabled_image:
+        self.background_checkbox_disabled_down \
+        if self.active else self.background_checkbox_disabled_normal
+    _radio_state_image:
+        self.background_radio_down \
+        if self.active else self.background_radio_normal
+    _radio_disabled_image:
+        self.background_radio_disabled_down \
+        if self.active else self.background_radio_disabled_normal
+    _checkbox_image:
+        self._checkbox_disabled_image \
+        if self.disabled else self._checkbox_state_image
+    _radio_image:
+        self._radio_disabled_image \
+        if self.disabled else self._radio_state_image
+    canvas:
+        Color:
+            rgba: self.color
+        Rectangle:
+            source: self._radio_image if self.group else self._checkbox_image
+            size: sp(32), sp(32)
+            pos: int(self.center_x - sp(16)), int(self.center_y - sp(16))
+
+# =============================================================================
+# Screen Manager
+# =============================================================================
+
+<ScreenManager>:
+    canvas.before:
+        StencilPush
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        StencilUse
+    canvas.after:
+        StencilUnUse
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        StencilPop
+
+# =============================================================================
+# Color Picker
+# =============================================================================
+<ColorPicker_Input@TextInput>
+    multiline: False
+    mroot: None
+    padding: sp(5)
+    border: 4, 9, 4, 9
+
+<ColorPicker_Label@Label>
+    mroot: None
+    size_hint_x: None
+    width: '30sp'
+    text_size: self.size
+    halign: "center"
+    valign: "middle"
+
+<ColorPicker_Selector@BoxLayout>
+    foreground_color: None
+    text: ''
+    mroot: None
+    mode: 'rgb'
+    color: 0
+    spacing: '2sp'
+    ColorPicker_Label:
+        text: root.text
+        mroot: root.mroot
+        color: root.foreground_color or (1, 1, 1, 1)
+    AnchorLayout:
+        size_hint_x: None
+        width: '50sp'
+        ColorPicker_Input:
+            mroot: root.mroot
+            text: str(int(sldr.value))
+            size_hint_y: None
+            height: '28sp'
+            on_text:
+                root.mroot._trigger_update_clr(root.mode, root.clr_idx, args[1])
+    Slider:
+        id: sldr
+        size_hint: 1, .25
+        pos_hint: {'center_y':.5}
+        range: 0, 255
+        value: root.color * 255
+        on_value:
+            root.mroot._trigger_update_clr(root.mode, root.clr_idx, args[1])
+
+<ColorWheel>:
+    _origin: self.center
+    _radius: 0.45 * min(self.size)
+
+<ColorPicker>:
+    foreground_color: (1, 1, 1, 1) if self.hsv[2] * root.color[3] < .5 else (0, 0, 0, 1)
+    wheel: wheel
+    BoxLayout:
+        orientation: 'vertical' if root.width < root.height else 'horizontal'
+        spacing: '5sp'
+        StackLayout:
+            orientation: 'tb-lr'
+            size_hint_y: None if root.width < root.height else 1
+            height: sp(33) * 4 if root.width < root.height else self.height
+            canvas:
+                Color:
+                    rgba: root.color
+                Rectangle:
+                    size: self.size
+                    pos: self.pos
+
+            ColorPicker_Selector:
+                mroot: root
+                text: 'R'
+                clr_idx: 0
+                color: root.color[0]
+                foreground_color: root.foreground_color
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+            ColorPicker_Selector:
+                mroot: root
+                text: 'G'
+                clr_idx: 1
+                color: root.color[1]
+                foreground_color: root.foreground_color
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+            ColorPicker_Selector:
+                mroot: root
+                text: 'B'
+                clr_idx: 2
+                color: root.color[2]
+                foreground_color: root.foreground_color
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+            ColorPicker_Selector:
+                mroot: root
+                text: 'A'
+                clr_idx: 3
+                color: root.color[3]
+                foreground_color: root.foreground_color
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+            ColorPicker_Selector:
+                mroot: root
+                mode: 'hsv'
+                text: 'H'
+                clr_idx: 0
+                color: root.hsv[0]
+                foreground_color: root.foreground_color
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+            ColorPicker_Selector:
+                mroot: root
+                mode: 'hsv'
+                text: 'S'
+                clr_idx: 1
+                color: root.hsv[1]
+                foreground_color: root.foreground_color
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+            ColorPicker_Selector:
+                mroot: root
+                mode: 'hsv'
+                text: 'V'
+                clr_idx: 2
+                color: root.hsv[2]
+                foreground_color: root.foreground_color
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+            BoxLayout:
+                size_hint_y: None if root.width < root.height else 0.125
+                size_hint_x: .5 if root.width < root.height else 1
+                height: '33sp' if root.width < root.height else self.height
+
+                spacing: '2sp'
+                ColorPicker_Label:
+                    mroot: root
+                    text: 'X'
+                    color: root.foreground_color
+                AnchorLayout:
+                    ColorPicker_Input:
+                        size_hint_y: None
+                        height: '28sp'
+                        mroot: root
+                        text: str(root.hex_color)
+                        on_text: root._trigger_update_hex(args[1])
+
+
+        ColorWheel:
+            id: wheel
+            color: root.color
+            on_color: root.set_color(args[1][:3])
diff --git a/kivy/deps/__init__.py b/kivy/deps/__init__.py
new file mode 100644
index 0000000..0eaf72f
--- /dev/null
+++ b/kivy/deps/__init__.py
@@ -0,0 +1,6 @@
+'''Kivy module for binary dependencies.
+
+Binary dependencies such as gstreamer is installed as a
+namespace module of kivy.deps. These modules are responsible
+for making sure that the binaries are available to kivy.
+'''
diff --git a/kivy/deps/__pycache__/__init__.cpython-310.pyc b/kivy/deps/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..b508d71
Binary files /dev/null and b/kivy/deps/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/effects/__init__.py b/kivy/effects/__init__.py
new file mode 100644
index 0000000..f43b138
--- /dev/null
+++ b/kivy/effects/__init__.py
@@ -0,0 +1,23 @@
+'''
+Effects
+=======
+
+.. versionadded:: 1.7.0
+
+Everything starts with the :class:`~kinetic.KineticEffect`, the base class for
+computing velocity out of a movement.
+
+This base class is used to implement the :class:`~scroll.ScrollEffect`, a base
+class used for our :class:`~kivy.uix.scrollview.ScrollView` widget effect.
+We have multiple implementations:
+
+- :class:`~kivy.effects.scroll.ScrollEffect`: base class used for implementing
+  an effect. It only calculates the scrolling and the overscroll.
+- :class:`~kivy.effects.dampedscroll.DampedScrollEffect`: uses the overscroll
+  information to allow the user to drag more than expected. Once the user stops
+  the drag, the position is returned to one of the bounds.
+- :class:`~kivy.effects.opacityscroll.OpacityScrollEffect`: uses the overscroll
+  information to reduce the opacity of the scrollview widget. When the user
+  stops the drag, the opacity is set back to 1.
+
+'''
diff --git a/kivy/effects/__pycache__/__init__.cpython-310.pyc b/kivy/effects/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..ce6114d
Binary files /dev/null and b/kivy/effects/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/effects/__pycache__/dampedscroll.cpython-310.pyc b/kivy/effects/__pycache__/dampedscroll.cpython-310.pyc
new file mode 100644
index 0000000..260e2dc
Binary files /dev/null and b/kivy/effects/__pycache__/dampedscroll.cpython-310.pyc differ
diff --git a/kivy/effects/__pycache__/kinetic.cpython-310.pyc b/kivy/effects/__pycache__/kinetic.cpython-310.pyc
new file mode 100644
index 0000000..298374d
Binary files /dev/null and b/kivy/effects/__pycache__/kinetic.cpython-310.pyc differ
diff --git a/kivy/effects/__pycache__/opacityscroll.cpython-310.pyc b/kivy/effects/__pycache__/opacityscroll.cpython-310.pyc
new file mode 100644
index 0000000..6de4fc6
Binary files /dev/null and b/kivy/effects/__pycache__/opacityscroll.cpython-310.pyc differ
diff --git a/kivy/effects/__pycache__/scroll.cpython-310.pyc b/kivy/effects/__pycache__/scroll.cpython-310.pyc
new file mode 100644
index 0000000..11160db
Binary files /dev/null and b/kivy/effects/__pycache__/scroll.cpython-310.pyc differ
diff --git a/kivy/effects/dampedscroll.py b/kivy/effects/dampedscroll.py
new file mode 100644
index 0000000..0c5744d
--- /dev/null
+++ b/kivy/effects/dampedscroll.py
@@ -0,0 +1,114 @@
+'''
+Damped scroll effect
+====================
+
+.. versionadded:: 1.7.0
+
+This damped scroll effect will use the
+:attr:`~kivy.effects.scroll.ScrollEffect.overscroll` to calculate the scroll
+value, and slows going back to the upper or lower limit.
+
+'''
+
+__all__ = ('DampedScrollEffect',)
+
+
+from kivy.effects.scroll import ScrollEffect
+from kivy.properties import NumericProperty, BooleanProperty
+from kivy.metrics import sp
+
+
+class DampedScrollEffect(ScrollEffect):
+    '''DampedScrollEffect class. See the module documentation for more
+    information.
+    '''
+
+    edge_damping = NumericProperty(0.25)
+    '''Edge damping.
+
+    :attr:`edge_damping` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.25
+    '''
+
+    spring_constant = NumericProperty(2.0)
+    '''Spring constant.
+
+    :attr:`spring_constant` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 2.0
+    '''
+
+    min_overscroll = NumericProperty(.5)
+    '''An overscroll less than this amount will be normalized to 0.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`min_overscroll` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to .5.
+    '''
+
+    round_value = BooleanProperty(True)
+    '''If True, when the motion stops, :attr:`value` is rounded to the nearest
+    integer.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`round_value` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    def update_velocity(self, dt):
+        if abs(self.velocity) <= self.min_velocity and self.overscroll == 0:
+            self.velocity = 0
+            # why does this need to be rounded? For now refactored it.
+            if self.round_value:
+                self.value = round(self.value)
+            return
+
+        total_force = self.velocity * self.friction * dt / self.std_dt
+        if abs(self.overscroll) > self.min_overscroll:
+            total_force += self.velocity * self.edge_damping
+            total_force += self.overscroll * self.spring_constant
+        else:
+            self.overscroll = 0
+
+        stop_overscroll = ''
+        if not self.is_manual:
+            if self.overscroll > 0 and self.velocity < 0:
+                stop_overscroll = 'max'
+            elif self.overscroll < 0 and self.velocity > 0:
+                stop_overscroll = 'min'
+
+        self.velocity = self.velocity - total_force
+        if not self.is_manual:
+            self.apply_distance(self.velocity * dt)
+            if stop_overscroll == 'min' and self.value > self.min:
+                self.value = self.min
+                self.velocity = 0
+                return
+            if stop_overscroll == 'max' and self.value < self.max:
+                self.value = self.max
+                self.velocity = 0
+                return
+        self.trigger_velocity_update()
+
+    def on_value(self, *args):
+        scroll_min = self.min
+        scroll_max = self.max
+        if scroll_min > scroll_max:
+            scroll_min, scroll_max = scroll_max, scroll_min
+        if self.value < scroll_min:
+            self.overscroll = self.value - scroll_min
+        elif self.value > scroll_max:
+            self.overscroll = self.value - scroll_max
+        else:
+            self.overscroll = 0
+        self.scroll = self.value
+
+    def on_overscroll(self, *args):
+        self.trigger_velocity_update()
+
+    def apply_distance(self, distance):
+        os = abs(self.overscroll)
+        if os:
+            distance /= 1. + os / sp(200.)
+        super(DampedScrollEffect, self).apply_distance(distance)
diff --git a/kivy/effects/kinetic.py b/kivy/effects/kinetic.py
new file mode 100644
index 0000000..a03e4d2
--- /dev/null
+++ b/kivy/effects/kinetic.py
@@ -0,0 +1,193 @@
+'''
+Kinetic effect
+==============
+
+.. versionadded:: 1.7.0
+
+The :class:`KineticEffect` is the base class that is used to compute the
+velocity out of a movement. When the movement is finished, the effect will
+compute the position of the movement according to the velocity, and reduce the
+velocity with a friction. The movement stop until the velocity is 0.
+
+Conceptually, the usage could be::
+
+    >>> effect = KineticEffect()
+    >>> effect.start(10)
+    >>> effect.update(15)
+    >>> effect.update(30)
+    >>> effect.stop(48)
+
+Over the time, you will start a movement of a value, update it, and stop the
+movement. At this time, you'll get the movement value into
+:attr:`KineticEffect.value`. On the example i've typed manually, the computed
+velocity will be::
+
+    >>> effect.velocity
+    3.1619100231163046
+
+After multiple clock interaction, the velocity will decrease according to
+:attr:`KineticEffect.friction`. The computed value will be stored in
+:attr:`KineticEffect.value`. The output of this `value` could be::
+
+    46.30038145219605
+    54.58302451968686
+    61.9229016256196
+    # ...
+
+'''
+
+__all__ = ('KineticEffect', )
+
+
+from time import time
+from kivy.event import EventDispatcher
+from kivy.properties import NumericProperty, BooleanProperty
+from kivy.clock import Clock
+
+
+class KineticEffect(EventDispatcher):
+    '''Kinetic effect class. See module documentation for more information.
+    '''
+
+    velocity = NumericProperty(0)
+    '''Velocity of the movement.
+
+    :attr:`velocity` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    friction = NumericProperty(0.05)
+    '''Friction to apply on the velocity
+
+    :attr:`friction` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.05.
+    '''
+
+    value = NumericProperty(0)
+    '''Value (during the movement and computed) of the effect.
+
+    :attr:`value` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    is_manual = BooleanProperty(False)
+    '''Indicate if a movement is in progress (True) or not (False).
+
+    :attr:`is_manual` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    max_history = NumericProperty(5)
+    '''Save up to `max_history` movement value into the history. This is used
+    for correctly calculating the velocity according to the movement.
+
+    :attr:`max_history` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 5.
+    '''
+
+    min_distance = NumericProperty(.1)
+    '''The minimal distance for a movement to have nonzero velocity.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`min_distance` is :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.1.
+    '''
+
+    min_velocity = NumericProperty(.5)
+    '''Velocity below this quantity is normalized to 0. In other words,
+    any motion whose velocity falls below this number is stopped.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`min_velocity` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.5.
+    '''
+
+    std_dt = NumericProperty(0.017)
+    ''' std_dt
+        correction update_velocity if dt is not constant
+
+    .. versionadded:: 2.0.0
+
+    :attr:`std_dt` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.017.
+    '''
+
+    def __init__(self, **kwargs):
+        self.history = []
+        self.trigger_velocity_update = Clock.create_trigger(
+            self.update_velocity, 0)
+        super(KineticEffect, self).__init__(**kwargs)
+
+    def apply_distance(self, distance):
+        if abs(distance) < self.min_distance:
+            self.velocity = 0
+        self.value += distance
+
+    def start(self, val, t=None):
+        '''Start the movement.
+
+        :Parameters:
+            `val`: float or int
+                Value of the movement
+            `t`: float, defaults to None
+                Time when the movement happen. If no time is set, it will use
+                time.time()
+        '''
+        self.is_manual = True
+        t = t or time()
+        self.velocity = 0
+        self.history = [(t, val)]
+
+    def update(self, val, t=None):
+        '''Update the movement.
+
+        See :meth:`start` for the arguments.
+        '''
+        t = t or time()
+        distance = val - self.history[-1][1]
+        self.apply_distance(distance)
+        self.history.append((t, val))
+        if len(self.history) > self.max_history:
+            self.history.pop(0)
+
+    def stop(self, val, t=None):
+        '''Stop the movement.
+
+        See :meth:`start` for the arguments.
+        '''
+        self.is_manual = False
+        t = t or time()
+        distance = val - self.history[-1][1]
+        self.apply_distance(distance)
+        newest_sample = (t, val)
+        old_sample = self.history[0]
+        for sample in self.history:
+            if (newest_sample[0] - sample[0]) < 10. / 60.:
+                break
+            old_sample = sample
+        distance = newest_sample[1] - old_sample[1]
+        duration = abs(newest_sample[0] - old_sample[0])
+        self.velocity = (distance / max(duration, 0.0001))
+        self.trigger_velocity_update()
+
+    def cancel(self):
+        '''Cancel a movement. This can be used in case :meth:`stop` cannot be
+        called. It will reset :attr:`is_manual` to False, and compute the
+        movement if the velocity is > 0.
+        '''
+        self.is_manual = False
+        self.trigger_velocity_update()
+
+    def update_velocity(self, dt):
+        '''(internal) Update the velocity according to the frametime and
+        friction.
+        '''
+        if abs(self.velocity) <= self.min_velocity:
+            self.velocity = 0
+            return
+
+        self.velocity -= self.velocity * self.friction * dt / self.std_dt
+        self.apply_distance(self.velocity * dt)
+        self.trigger_velocity_update()
diff --git a/kivy/effects/opacityscroll.py b/kivy/effects/opacityscroll.py
new file mode 100644
index 0000000..735d4da
--- /dev/null
+++ b/kivy/effects/opacityscroll.py
@@ -0,0 +1,27 @@
+'''
+Opacity scroll effect
+=====================
+
+Based on the :class:`~kivy.effects.damped.DampedScrollEffect`, this one will
+also decrease the opacity of the target widget during the overscroll.
+
+'''
+
+__all__ = ('OpacityScrollEffect', )
+
+
+from kivy.effects.dampedscroll import DampedScrollEffect
+
+
+class OpacityScrollEffect(DampedScrollEffect):
+    '''OpacityScrollEffect class. Uses the overscroll
+    information to reduce the opacity of the scrollview widget. When the user
+    stops the drag, the opacity is set back to 1.
+    '''
+
+    def on_overscroll(self, *args):
+        if self.target_widget and self.target_widget.height != 0:
+            alpha = (1.0 -
+                     abs(self.overscroll / float(self.target_widget.height)))
+            self.target_widget.opacity = min(1, alpha)
+        self.trigger_velocity_update()
diff --git a/kivy/effects/scroll.py b/kivy/effects/scroll.py
new file mode 100644
index 0000000..0c10d04
--- /dev/null
+++ b/kivy/effects/scroll.py
@@ -0,0 +1,126 @@
+'''
+Scroll effect
+=============
+
+.. versionadded:: 1.7.0
+
+Based on the :class:`~kivy.effects.kinetic` effect, the :class:`ScrollEffect`
+will limit the movement to bounds determined by its :attr:`~ScrollEffect.min`
+and :attr:`~ScrollEffect.max` properties. If the movement exceeds these
+bounds, it will calculate the amount of :attr:`~ScrollEffect.overscroll` and
+try to return to the value of one of the bounds.
+
+This is very useful for implementing a scrolling list. We actually use this
+class as a base effect for our :class:`~kivy.uix.scrollview.ScrollView` widget.
+
+'''
+
+
+__all__ = ('ScrollEffect', )
+
+
+from time import time
+from kivy.effects.kinetic import KineticEffect
+from kivy.uix.widget import Widget
+from kivy.properties import NumericProperty, ObjectProperty
+
+
+class ScrollEffect(KineticEffect):
+    '''ScrollEffect class. See the module documentation for more information.
+    '''
+
+    drag_threshold = NumericProperty('20sp')
+    '''Minimum distance to travel before the movement is considered as a drag.
+
+    :attr:`drag_threshold` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 20sp.
+    '''
+
+    min = NumericProperty(0)
+    '''Minimum boundary to use for scrolling.
+
+    :attr:`min` is a :class:`~kivy.properties.NumericProperty` and defaults to
+    0.
+    '''
+
+    max = NumericProperty(0)
+    '''Maximum boundary to use for scrolling.
+
+    :attr:`max` is a :class:`~kivy.properties.NumericProperty` and defaults to
+    0.
+    '''
+
+    scroll = NumericProperty(0)
+    '''Computed value for scrolling. This value is different from
+    :py:attr:`kivy.effects.kinetic.KineticEffect.value`
+    in that it will return to one of the min/max bounds.
+
+    :attr:`scroll` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0.
+    '''
+
+    overscroll = NumericProperty(0)
+    '''Computed value when the user over-scrolls i.e. goes out of the bounds.
+
+    :attr:`overscroll` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    target_widget = ObjectProperty(None, allownone=True, baseclass=Widget)
+    '''Widget to attach to this effect. Even if this class doesn't make changes
+    to the `target_widget` by default, subclasses can use it to change the
+    graphics or apply custom transformations.
+
+    :attr:`target_widget` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    displacement = NumericProperty(0)
+    '''Cumulative distance of the movement during the interaction. This is used
+    to determine if the movement is a drag (more than :attr:`drag_threshold`)
+    or not.
+
+    :attr:`displacement` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    def reset(self, pos):
+        '''(internal) Reset the value and the velocity to the `pos`.
+        Mostly used when the bounds are checked.
+        '''
+        self.value = pos
+        self.velocity = 0
+        if self.history:
+            val = self.history[-1][1]
+            self.history = [(time(), val)]
+
+    def on_value(self, *args):
+        scroll_min = self.min
+        scroll_max = self.max
+        if scroll_min > scroll_max:
+            scroll_min, scroll_max = scroll_max, scroll_min
+        if self.value < scroll_min:
+            self.overscroll = self.value - scroll_min
+            self.reset(scroll_min)
+        elif self.value > scroll_max:
+            self.overscroll = self.value - scroll_max
+            self.reset(scroll_max)
+        else:
+            self.scroll = self.value
+
+    def start(self, val, t=None):
+        self.is_manual = True
+        self.displacement = 0
+        return super(ScrollEffect, self).start(val, t)
+
+    def update(self, val, t=None):
+        self.displacement += abs(val - self.history[-1][1])
+        return super(ScrollEffect, self).update(val, t)
+
+    def stop(self, val, t=None):
+        self.is_manual = False
+        self.displacement += abs(val - self.history[-1][1])
+        if self.displacement <= self.drag_threshold:
+            self.velocity = 0
+            return
+        return super(ScrollEffect, self).stop(val, t)
diff --git a/kivy/event.py b/kivy/event.py
new file mode 100644
index 0000000..52f352c
--- /dev/null
+++ b/kivy/event.py
@@ -0,0 +1,12 @@
+# This is a "jumping" module, required for python-for-android project
+# Because we are putting all the module into the same .so, there can be name
+# conflict. We have one conflict with pygame.event and kivy.event => Both are
+# python extension and have the same "initevent" symbol. So right now, just
+# rename this one.
+__all__ = ('EventDispatcher', 'ObjectWithUid', 'Observable')
+
+import kivy._event
+__doc__ = kivy._event.__doc__
+EventDispatcher = kivy._event.EventDispatcher
+ObjectWithUid = kivy._event.ObjectWithUid
+Observable = kivy._event.Observable
diff --git a/kivy/eventmanager/__init__.py b/kivy/eventmanager/__init__.py
new file mode 100644
index 0000000..6a78cc1
--- /dev/null
+++ b/kivy/eventmanager/__init__.py
@@ -0,0 +1,185 @@
+'''
+Event Manager
+=============
+
+The :class:`EventManagerBase` is the abstract class intended for specific
+implementation of dispatching motion events
+(instances of :class:`~kivy.input.motionevent.MotionEvent`) to widgets through
+:meth:`~kivy.uix.widget.Widget.on_motion` method of the
+:class:`~kivy.uix.widget.Widget` class.
+
+.. warning::
+    This feature is experimental and it remains so while this warning is
+    present.
+
+Manager is a layer between the window and its widgets.
+:class:`~kivy.core.window.WindowBase` will forward all the events it receives
+in :meth:`~kivy.core.window.WindowBase.on_motion` method to the all managers
+who declared to receive types of those events. Event will continue to go
+through the managers list even if one of them accept it (by returning `True`).
+
+When to use an event manager
+----------------------------
+
+Use a manager when you want to:
+
+- Dispatch touch, hover, keyboard, joystick or any other events to the widgets
+  through :meth:`~kivy.uix.widget.Widget.on_motion` method.
+- Dispatch filtered motion events by any criteria, like by a
+  :attr:`~kivy.input.motionevent.MotionEvent.device` or a
+  :attr:`~kivy.input.motionevent.MotionEvent.profile`.
+- Combine several motion events (touch, hover etc.) into one new event and
+  dispatch it to the widgets.
+- Dispatch one-time generic events, like app pause/resume.
+- Write an event simulator, like a touch simulator which draws a circle on
+  window's canvas for every simulated touch.
+
+Defining and registering an event manager
+-----------------------------------------
+
+1. Inherit :class:`EventManagerBase` and set which events this manager
+   should receive by declaring event types in
+   :attr:`EventManagerBase.type_ids` attribute.
+2. Implement :meth:`EventManagerBase.dispatch` which will be called by window
+   to pass event type (one of "begin", "update", "end") and an event.
+3. Implement :meth:`EventManagerBase.start` and :meth:`EventManagerBase.stop`
+   to allocate and release additional resources if needed.
+4. Register a manager instance to window using method
+   :meth:`~kivy.core.window.WindowBase.register_event_manager`. This can be
+   done by overriding methods :meth:`~kivy.app.App.build` or
+   :meth:`~kivy.app.App.on_start`.
+
+All registered managers are kept in the
+:attr:`~kivy.core.window.WindowBase.event_managers` list. To unregister a
+manager call :meth:`~kivy.core.window.WindowBase.unregister_event_manager`
+which itself can be called in :meth:`~kivy.app.App.on_stop` method.
+
+Dispatching events to the widgets
+---------------------------------
+
+Once registered, window will start the manager and forward all events of types
+declared in :attr:`EventManagerBase.type_ids` to the manager's
+:meth:`EventManagerBase.dispatch` method. It's up to manager to decide how to
+dispatch them, either by going through :attr:`EventManagerBase.window.children`
+list and dispatching `on_motion` event or by using some different logic. It's
+also up to manager to dispatch grabbed events if grab feature is supported by
+the event (see :meth:`~kivy.input.motionevent.MotionEvent.grab` and
+:meth:`~kivy.input.motionevent.MotionEvent.ungrab` methods).
+
+Manager can assign a different dispatch mode to decide how event
+should be dispatched throughout the widget tree by changing the value of the
+:attr:`~kivy.input.motionevent.MotionEvent.dispatch_mode` attribute. Before
+changing the mode manager should store/restore the current one, either by using
+a local variable or by using event's
+:meth:`~kivy.input.motionevent.MotionEvent.push` /
+:meth:`~kivy.input.motionevent.MotionEvent.pop` methods.
+
+Currently there are three dispatch modes (behaviors) recognized by the
+`on_motion` method in :class:`~kivy.uix.widget.Widget` class:
+
+1. Default dispatch (requires :const:`MODE_DEFAULT_DISPATCH`) - event will go
+   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. Mode :const:`MODE_DEFAULT_DISPATCH` is assigned by default in
+   :class:`~kivy.input.motionevent.MotionEvent` class.
+2. Filtered dispatch (requires :const:`MODE_FILTERED_DISPATCH`) - event will go
+   only through registered child widgets.
+3. No dispatch to children (requires :const:`MODE_DONT_DISPATCH`) - event will
+   not be dispatched to child widgets.
+
+Note that window does not have a `motion_filter` property and therefore does
+not have a list of filtered widgets from its `children` list.
+'''
+
+MODE_DEFAULT_DISPATCH = 'default'
+'''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.
+
+.. versionadded:: 2.1.0
+'''
+
+MODE_FILTERED_DISPATCH = 'filtered'
+'''Assign this mode to make event dispatch only to child widgets which were
+previously registered to receive events of the same
+:attr:`~kivy.input.motionevent.MotionEvent.type_id` and not to all
+child widgets.
+
+.. versionadded:: 2.1.0
+'''
+
+MODE_DONT_DISPATCH = 'none'
+'''Assign this mode to prevent event from dispatching to child widgets.
+
+.. versionadded:: 2.1.0
+'''
+
+
+class EventManagerBase(object):
+    '''Abstract class with methods :meth:`start`, :meth:`stop` and
+    :meth:`dispatch` for specific class to implement.
+
+    Example of the manager receiving touch and hover events::
+
+        class TouchHoverManager(EventManagerBase):
+
+            type_ids = ('touch', 'hover')
+
+            def start(self):
+                # Create additional resources, bind callbacks to self.window
+
+            def dispatch(self, etype, me):
+                if me.type_id == 'touch':
+                    # Handle touch event
+                elif me.type_id == 'hover'
+                    # Handle hover event
+
+            def stop(self):
+                # Release resources
+
+    '''
+
+    type_ids = None
+    '''Override this attribute to declare the type ids of the events which
+    manager wants to receive. This attribute will be used by
+    :class:`~kivy.core.window.WindowBase` to know which events to pass to the
+    :meth:`dispatch` method.
+
+    .. versionadded:: 2.1.0
+    '''
+
+    window = None
+    '''Holds the instance of the :class:`~kivy.core.window.WindowBase`.
+
+    .. versionadded:: 2.1.0
+    '''
+
+    def start(self):
+        '''Start the manager, bind callbacks to the objects and create
+        additional resources. Attribute :attr:`window` is assigned when this
+        method is called.
+
+        .. versionadded:: 2.1.0
+        '''
+
+    def dispatch(self, etype, me):
+        '''Dispatch event `me` to the widgets in the :attr:`window`.
+
+        :Parameters:
+            `etype`: `str`
+                One of "begin", "update" or "end"
+            `me`: :class:`~kivy.input.motionevent.MotionEvent`
+                The Motion Event currently dispatched.
+        :Returns: `bool`
+            `True` to stop event dispatching
+
+        .. versionadded:: 2.1.0
+        '''
+
+    def stop(self):
+        '''Stop the manager, unbind from any objects and release any allocated
+        resources.
+
+        .. versionadded:: 2.1.0
+        '''
diff --git a/kivy/eventmanager/__pycache__/__init__.cpython-310.pyc b/kivy/eventmanager/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..9dc87b0
Binary files /dev/null and b/kivy/eventmanager/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/extras/__init__.py b/kivy/extras/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/kivy/extras/__pycache__/__init__.cpython-310.pyc b/kivy/extras/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..e5767c2
Binary files /dev/null and b/kivy/extras/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/extras/__pycache__/highlight.cpython-310.pyc b/kivy/extras/__pycache__/highlight.cpython-310.pyc
new file mode 100644
index 0000000..447d7c7
Binary files /dev/null and b/kivy/extras/__pycache__/highlight.cpython-310.pyc differ
diff --git a/kivy/extras/highlight.py b/kivy/extras/highlight.py
new file mode 100644
index 0000000..f8808af
--- /dev/null
+++ b/kivy/extras/highlight.py
@@ -0,0 +1,52 @@
+'''Pygments lexer for kv language
+'''
+from pygments.lexer import RegexLexer, bygroups, using
+from pygments.lexers.agile import PythonLexer
+from pygments import highlight
+from pygments.token import Comment, Text, Name, Punctuation, Operator
+from pygments.formatters import get_formatter_by_name
+import sys
+
+
+class KivyLexer(RegexLexer):
+    name = 'Kivy'
+    aliases = ['kivy', 'kv']
+    filenames = ['*.kv']
+    tokens = {
+        'root': [
+            (r'#:.*?$', Comment.Preproc),
+            (r'#.*?$', using(PythonLexer)),
+            (r'\s+', Text),
+            (r'<.+>', Name.Namespace),
+            (r'(\[)(\s*)(.*?)(\s*)(@)',
+                bygroups(Punctuation, Text, Name.Class, Text, Operator),
+                'classList'),
+            (r'[A-Za-z][A-Za-z0-9]*$', Name.Attribute),
+            (r'(.*?)(\s*)(:)(\s*)$',
+                bygroups(Name.Class, Text, Punctuation, Text)),
+            (r'(.*?)(\s*)(:)(\s*)(.*?)$',
+                bygroups(Name.Attribute, Text, Punctuation, Text,
+                using(PythonLexer))),
+            (r'[^:]+?$', using(PythonLexer))],
+        'classList': [
+            (r'(,)(\s*)([A-Z][A-Za-z0-9]*)',
+                bygroups(Punctuation, Text, Name.Class)),
+            (r'(\+)(\s*)([A-Z][A-Za-z0-9]*)',
+                bygroups(Operator, Text, Name.Class)),
+            (r'\s+', Text),
+            (r'[A-Z][A-Za-z0-9]*', Name.Class),
+            (r'\]', Punctuation, '#pop')]}
+
+
+if __name__ == '__main__':
+    ''' This lexer will highlight .kv file. The first argument is the source
+    file, the second argument is the format of the destination and the third
+    argument is the output filename
+    '''
+    if len(sys.argv) != 4:
+        raise Exception('Three arguments expected, found %s' %
+            (len(sys.argv) - 1))
+    k = KivyLexer()
+    with open(sys.argv[1], 'r') as fd:
+        with open(sys.argv[3], 'w') as out:
+            highlight(fd.read(), k, get_formatter_by_name(sys.argv[2]), out)
diff --git a/kivy/factory.py b/kivy/factory.py
new file mode 100644
index 0000000..3a446d2
--- /dev/null
+++ b/kivy/factory.py
@@ -0,0 +1,190 @@
+'''
+Factory object
+==============
+
+The factory can be used to automatically register any class or module
+and instantiate classes from it anywhere in your project. It is an
+implementation of the
+`Factory Pattern <http://en.wikipedia.org/wiki/Factory_pattern>`_.
+
+The class list and available modules are automatically generated by setup.py.
+
+Example for registering a class/module::
+
+    >>> from kivy.factory import Factory
+    >>> Factory.register('Widget', module='kivy.uix.widget')
+    >>> Factory.register('Vector', module='kivy.vector')
+
+Example of using the Factory::
+
+    >>> from kivy.factory import Factory
+    >>> widget = Factory.Widget(pos=(456,456))
+    >>> vector = Factory.Vector(9, 2)
+
+Example using a class name::
+
+    >>> from kivy.factory import Factory
+    >>> Factory.register('MyWidget', cls=MyWidget)
+
+By default, the first classname you register via the factory is permanent.
+If you wish to change the registered class, you need to unregister the
+classname before you re-assign it::
+
+    >>> from kivy.factory import Factory
+    >>> Factory.register('MyWidget', cls=MyWidget)
+    >>> widget = Factory.MyWidget()
+    >>> Factory.unregister('MyWidget')
+    >>> Factory.register('MyWidget', cls=CustomWidget)
+    >>> customWidget = Factory.MyWidget()
+'''
+
+__all__ = ('Factory', 'FactoryBase', 'FactoryException')
+
+import copy
+import importlib
+from kivy.logger import Logger
+from kivy.context import register_context
+
+
+class FactoryException(Exception):
+    pass
+
+
+class FactoryBase(object):
+
+    def __init__(self):
+        super(FactoryBase, self).__init__()
+        self.classes = {}
+
+    @classmethod
+    def create_from(cls, factory):
+        """Creates a instance of the class, and initializes to the state of
+        ``factory``.
+
+        :param factory: The factory to initialize from.
+        :return: A new instance of this class.
+        """
+        obj = cls()
+        obj.classes = copy.copy(factory.classes)
+        return obj
+
+    def is_template(self, classname):
+        '''Return True if the classname is a template from the
+        :class:`~kivy.lang.Builder`.
+
+        .. versionadded:: 1.0.5
+        '''
+        if classname in self.classes:
+            return self.classes[classname]['is_template']
+        else:
+            return False
+
+    def register(self, classname, cls=None, module=None, is_template=False,
+                 baseclasses=None, filename=None, warn=False):
+        '''Register a new classname referring to a real class or
+        class definition in a module. Warn, if True will emit a warning message
+        when a class is re-declared.
+
+        .. versionchanged:: 1.9.0
+            `warn` was added.
+
+        .. versionchanged:: 1.7.0
+            :attr:`baseclasses` and :attr:`filename` added
+
+        .. versionchanged:: 1.0.5
+            :attr:`is_template` has been added in 1.0.5.
+        '''
+        if cls is None and module is None and baseclasses is None:
+            raise ValueError(
+                'You must specify either cls= or module= or baseclasses =')
+        if classname in self.classes:
+            if warn:
+                info = self.classes[classname]
+                Logger.warning('Factory: Ignored class "{}" re-declaration. '
+                'Current -  module: {}, cls: {}, baseclass: {}, filename: {}. '
+                'Ignored -  module: {}, cls: {}, baseclass: {}, filename: {}.'.
+                format(classname, info['module'], info['cls'],
+                       info['baseclasses'], info['filename'], module, cls,
+                       baseclasses, filename))
+            return
+        self.classes[classname] = {
+            'module': module,
+            'cls': cls,
+            'is_template': is_template,
+            'baseclasses': baseclasses,
+            'filename': filename}
+
+    def unregister(self, *classnames):
+        '''Unregisters the classnames previously registered via the
+        register method. This allows the same classnames to be re-used in
+        different contexts.
+
+        .. versionadded:: 1.7.1
+        '''
+        for classname in classnames:
+            if classname in self.classes:
+                self.classes.pop(classname)
+
+    def unregister_from_filename(self, filename):
+        '''Unregister all the factory objects related to the filename passed in
+        the parameter.
+
+        .. versionadded:: 1.7.0
+        '''
+        to_remove = [x for x in self.classes
+                     if self.classes[x]['filename'] == filename]
+        for name in to_remove:
+            del self.classes[name]
+
+    def __getattr__(self, name):
+        classes = self.classes
+        if name not in classes:
+            if name[0] == name[0].lower():
+                # if trying to access attributes like checking for `bind`
+                # then raise AttributeError
+                raise AttributeError(
+                    'First letter of class name <%s> is in lowercase' % name)
+            raise FactoryException('Unknown class <%s>' % name)
+
+        item = classes[name]
+        cls = item['cls']
+
+        # No class to return, import the module
+        if cls is None:
+            if item['module']:
+                module = importlib.__import__(
+                    name=item['module'],
+                    fromlist='*',
+                    level=0  # force absolute
+                )
+                if not hasattr(module, name):
+                    raise FactoryException(
+                        'No class named <%s> in module <%s>' % (
+                            name, item['module']))
+                cls = item['cls'] = getattr(module, name)
+
+            elif item['baseclasses']:
+                rootwidgets = []
+                for basecls in item['baseclasses'].split('+'):
+                    rootwidgets.append(Factory.get(basecls))
+                cls = item['cls'] = type(str(name), tuple(rootwidgets), {})
+
+            else:
+                raise FactoryException('No information to create the class')
+
+        return cls
+
+    get = __getattr__
+
+
+#: Factory instance to use for getting new classes
+Factory: FactoryBase = register_context('Factory', FactoryBase)
+
+# Now import the file with all registers
+# automatically generated by build_factory
+import kivy.factory_registers  # NOQA
+Logger.info('Factory: %d symbols loaded' % len(Factory.classes))
+
+if __name__ == '__main__':
+    Factory.register('Vector', module='kivy.vector')
+    Factory.register('Widget', module='kivy.uix.widget')
diff --git a/kivy/factory_registers.py b/kivy/factory_registers.py
new file mode 100644
index 0000000..d080573
--- /dev/null
+++ b/kivy/factory_registers.py
@@ -0,0 +1,195 @@
+# Auto-generated file by setup.py build_factory
+
+from kivy.factory import Factory
+
+r = Factory.register
+r('Animation', module='kivy.animation')
+r('AnimationTransition', module='kivy.animation')
+r('ExceptionHandler', module='kivy.base')
+r('Cache', module='kivy.cache')
+r('ClockBase', module='kivy.clock')
+r('ColorPicker', module='kivy.uix.colorpicker')
+r('ColorWheel', module='kivy.uix.colorpicker')
+r('ConfigParser', module='kivy.config')
+r('EventDispatcher', module='kivy.event')
+r('Observable', module='kivy.event')
+r('FactoryException', module='kivy.factory')
+r('Gesture', module='kivy.gesture')
+r('GestureDatabase', module='kivy.gesture')
+r('GesturePoint', module='kivy.gesture')
+r('GestureStroke', module='kivy.gesture')
+r('Parser', module='kivy.lang.parser')
+r('LoaderBase', module='kivy.loader')
+r('ProxyImage', module='kivy.loader')
+r('LoggerHistory', module='kivy.logger')
+r('NumericProperty', module='kivy.properties')
+r('StringProperty', module='kivy.properties')
+r('ListProperty', module='kivy.properties')
+r('ObjectProperty', module='kivy.properties')
+r('BooleanProperty', module='kivy.properties')
+r('BoundedNumericProperty', module='kivy.properties')
+r('OptionProperty', module='kivy.properties')
+r('ReferenceListProperty', module='kivy.properties')
+r('AliasProperty', module='kivy.properties')
+r('NumericProperty', module='kivy.properties')
+r('DictProperty', module='kivy.properties')
+r('VariableListProperty', module='kivy.properties')
+r('ConfigParserProperty', module='kivy.properties')
+r('ColorProperty', module='kivy.properties')
+r('Property', module='kivy.properties')
+r('SafeList', module='kivy.utils')
+r('Vector', module='kivy.vector')
+r('Color', module='kivy.graphics.context_instructions')
+r('BindTexture', module='kivy.graphics.context_instructions')
+r('PushMatrix', module='kivy.graphics.context_instructions')
+r('PopMatrix', module='kivy.graphics.context_instructions')
+r('Rotate', module='kivy.graphics.context_instructions')
+r('Scale', module='kivy.graphics.context_instructions')
+r('Translate', module='kivy.graphics.context_instructions')
+r('Transform', module='kivy.graphics.context_instructions')
+r('MatrixInstruction', module='kivy.graphics.context_instructions')
+r('Fbo', module='kivy.graphics.fbo')
+r('Instruction', module='kivy.graphics.instructions')
+r('InstructionGroup', module='kivy.graphics.instructions')
+r('ContextInstruction', module='kivy.graphics.instructions')
+r('VertexInstruction', module='kivy.graphics.instructions')
+r('Canvas', module='kivy.graphics.instructions')
+r('CanvasBase', module='kivy.graphics.instructions')
+r('Callback', module='kivy.graphics.instructions')
+r('RenderContext', module='kivy.graphics.instructions')
+r('Shader', module='kivy.graphics.shader')
+r('Texture', module='kivy.graphics.texture')
+r('TextureRegion', module='kivy.graphics.texture')
+r('Matrix', module='kivy.graphics.transformation')
+r('VBO', module='kivy.graphics.vbo')
+r('VertexBatch', module='kivy.graphics.vbo')
+r('StencilPush', module='kivy.graphics.stencil_instructions')
+r('StencilPop', module='kivy.graphics.stencil_instructions')
+r('StencilUse', module='kivy.graphics.stencil_instructions')
+r('StencilUnUse', module='kivy.graphics.stencil_instructions')
+r('ScissorPush', module='kivy.graphics.scissor_instructions')
+r('ScissorPop', module='kivy.graphics.scissor_instructions')
+r('Triangle', module='kivy.graphics.vertex_instructions')
+r('Quad', module='kivy.graphics.vertex_instructions')
+r('Rectangle', module='kivy.graphics.vertex_instructions')
+r('RoundedRectangle', module='kivy.graphics.vertex_instructions')
+r('BorderImage', module='kivy.graphics.vertex_instructions')
+r('Ellipse', module='kivy.graphics.vertex_instructions')
+r('Line', module='kivy.graphics.vertex_instructions')
+r('SmoothLine', module='kivy.graphics.vertex_instructions')
+r('Point', module='kivy.graphics.vertex_instructions')
+r('Bezier', module='kivy.graphics.vertex_instructions')
+r('Mesh', module='kivy.graphics.vertex_instructions')
+r('Svg', module='kivy.graphics.svg')
+r('MotionEventFactory', module='kivy.input.factory')
+r('MotionEventProvider', module='kivy.input.provider')
+r('Shape', module='kivy.input.shape')
+r('ShapeRect', module='kivy.input.shape')
+r('ActionBar', module='kivy.uix.actionbar')
+r('ActionItem', module='kivy.uix.actionbar')
+r('ActionButton', module='kivy.uix.actionbar')
+r('ActionToggleButton', module='kivy.uix.actionbar')
+r('ActionCheck', module='kivy.uix.actionbar')
+r('ActionSeparator', module='kivy.uix.actionbar')
+r('ActionDropDown', module='kivy.uix.actionbar')
+r('ActionGroup', module='kivy.uix.actionbar')
+r('ActionOverflow', module='kivy.uix.actionbar')
+r('ActionView', module='kivy.uix.actionbar')
+r('ContextualActionView', module='kivy.uix.actionbar')
+r('AnchorLayout', module='kivy.uix.anchorlayout')
+r('BoxLayout', module='kivy.uix.boxlayout')
+r('GridLayout', module='kivy.uix.gridlayout')
+r('PageLayout', module='kivy.uix.pagelayout')
+r('Accordion', module='kivy.uix.accordion')
+r('AccordionItem', module='kivy.uix.accordion')
+r('Button', module='kivy.uix.button')
+r('ButtonBehavior', module='kivy.uix.behaviors.button')
+r('ToggleButtonBehavior', module='kivy.uix.behaviors.togglebutton')
+r('DragBehavior', module='kivy.uix.behaviors.drag')
+r('FocusBehavior', module='kivy.uix.behaviors.focus')
+r('CompoundSelectionBehavior', module='kivy.uix.behaviors.compoundselection')
+r('KNSpaceBehavior', module='kivy.uix.behaviors.knspace')
+r('CodeNavigationBehavior', module='kivy.uix.behaviors.codenavigation')
+r('TouchRippleBehavior', module='kivy.uix.behaviors.touchripple')
+r('TouchRippleButtonBehavior', module='kivy.uix.behaviors.touchripple')
+r('EmacsBehavior', module='kivy.uix.behaviors.emacs')
+r('CoverBehavior', module='kivy.uix.behaviors.cover')
+r('Bubble', module='kivy.uix.bubble')
+r('BubbleButton', module='kivy.uix.bubble')
+r('Camera', module='kivy.uix.camera')
+r('Carousel', module='kivy.uix.carousel')
+r('CodeInput', module='kivy.uix.codeinput')
+r('CheckBox', module='kivy.uix.checkbox')
+r('DropDown', module='kivy.uix.dropdown')
+r('EffectWidget', module='kivy.uix.effectwidget')
+r('FloatLayout', module='kivy.uix.floatlayout')
+r('RelativeLayout', module='kivy.uix.relativelayout')
+r('ScatterLayout', module='kivy.uix.scatterlayout')
+r('ScatterPlaneLayout', module='kivy.uix.scatterlayout')
+r('FileChooserListView', module='kivy.uix.filechooser')
+r('FileChooserIconView', module='kivy.uix.filechooser')
+r('FileChooser', module='kivy.uix.filechooser')
+r('Image', module='kivy.uix.image')
+r('AsyncImage', module='kivy.uix.image')
+r('Label', module='kivy.uix.label')
+r('Layout', module='kivy.uix.layout')
+r('ModalView', module='kivy.uix.modalview')
+r('ProgressBar', module='kivy.uix.progressbar')
+r('Popup', module='kivy.uix.popup')
+r('Scatter', module='kivy.uix.scatter')
+r('ScatterPlane', module='kivy.uix.scatter')
+r('ScrollView', module='kivy.uix.scrollview')
+r('Settings', module='kivy.uix.settings')
+r('Slider', module='kivy.uix.slider')
+r('Screen', module='kivy.uix.screenmanager')
+r('ScreenManager', module='kivy.uix.screenmanager')
+r('Spinner', module='kivy.uix.spinner')
+r('Splitter', module='kivy.uix.splitter')
+r('StackLayout', module='kivy.uix.stacklayout')
+r('StencilView', module='kivy.uix.stencilview')
+r('Switch', module='kivy.uix.switch')
+r('TabbedPanel', module='kivy.uix.tabbedpanel')
+r('TabbedPanelHeader', module='kivy.uix.tabbedpanel')
+r('TextInput', module='kivy.uix.textinput')
+r('ToggleButton', module='kivy.uix.togglebutton')
+r('TreeView', module='kivy.uix.treeview')
+r('TreeViewLabel', module='kivy.uix.treeview')
+r('TreeViewNode', module='kivy.uix.treeview')
+r('ShaderTransition', module='kivy.uix.screenmanager')
+r('SlideTransition', module='kivy.uix.screenmanager')
+r('SwapTransition', module='kivy.uix.screenmanager')
+r('WipeTransition', module='kivy.uix.screenmanager')
+r('FadeTransition', module='kivy.uix.screenmanager')
+r('Sandbox', module='kivy.uix.sandbox')
+r('Video', module='kivy.uix.video')
+r('VideoPlayer', module='kivy.uix.videoplayer')
+r('VideoPlayerVolume', module='kivy.uix.videoplayer')
+r('VideoPlayerStop', module='kivy.uix.videoplayer')
+r('VideoPlayerPlayPause', module='kivy.uix.videoplayer')
+r('VideoPlayerProgressBar', module='kivy.uix.videoplayer')
+r('VKeyboard', module='kivy.uix.vkeyboard')
+r('Widget', module='kivy.uix.widget')
+r('WidgetException', module='kivy.uix.widget')
+r('RstDocument', module='kivy.uix.rst')
+r('KineticEffect', module='kivy.effects.kinetic')
+r('ScrollEffect', module='kivy.effects.scroll')
+r('DampedScrollEffect', module='kivy.effects.dampedscroll')
+r('OpacityScrollEffect', module='kivy.effects.opacityscroll')
+r('Recognizer', module='kivy.multistroke')
+r('MultistrokeGesture', module='kivy.multistroke')
+r('UnistrokeTemplate', module='kivy.multistroke')
+r('ProgressTracker', module='kivy.multistroke')
+r('GestureSurface', module='kivy.uix.gesturesurface')
+r('GestureContainer', module='kivy.uix.gesturesurface')
+r('RecycleViewBehavior', module='kivy.uix.recycleview.__init__')
+r('RecycleView', module='kivy.uix.recycleview.__init__')
+r('LayoutSelectionBehavior', module='kivy.uix.recycleview.layout')
+r('RecycleLayoutManagerBehavior', module='kivy.uix.recycleview.layout')
+r('RecycleDataViewBehavior', module='kivy.uix.recycleview.views')
+r('RecycleKVIDsDataViewBehavior', module='kivy.uix.recycleview.views')
+r('RecycleDataAdapter', module='kivy.uix.recycleview.views')
+r('RecycleDataModelBehavior', module='kivy.uix.recycleview.datamodel')
+r('RecycleDataModel', module='kivy.uix.recycleview.datamodel')
+r('RecycleLayout', module='kivy.uix.recyclelayout')
+r('RecycleGridLayout', module='kivy.uix.recyclegridlayout')
+r('RecycleBoxLayout', module='kivy.uix.recycleboxlayout')
diff --git a/kivy/garden/__init__.py b/kivy/garden/__init__.py
new file mode 100644
index 0000000..68b8238
--- /dev/null
+++ b/kivy/garden/__init__.py
@@ -0,0 +1,189 @@
+'''
+Garden
+======
+
+.. versionadded:: 1.7.0
+
+.. versionchanged:: 1.11.1
+
+Garden is a project to centralize addons for Kivy maintained by users. You can
+find more information at `Kivy Garden <http://kivy-garden.github.io/>`_. All
+the garden packages are centralized on the `kivy-garden Github
+<https://github.com/kivy-garden>`_ repository.
+
+.. warning::
+
+    The garden flower widgets are contributed by regular users such as
+    yourself. The kivy developers do not take any responsibility for the code
+    hosted in the garden organization repositories - we do not actively monitor
+    the flower repos. Please use at your own risk.
+
+Update to garden structure
+--------------------------
+
+Starting with the kivy 1.11.0 release, kivy has
+`shifted <https://github.com/kivy/kivy/wiki/Moving-kivy.garden.xxx-to-kivy_\
+garden.xxx-and-kivy.deps.xxx-to-kivy_deps.xxx>`_ from using the garden legacy
+tool that installs flowers with `garden install flower` where the flower
+does not have a proper python package structure to flowers that can be
+installed with pip and uploaded to pypi. Kivy supports the legacy garden
+flowers side by side with the newer packages so the garden tool and legacy
+flowers will be able to be used indefinitely. But we will only provide support
+for the newer packages format in the future.
+
+For garden package maintainers - for a guide how to migrate your garden package
+from the legacy structure `garden.flower` to the newer `flower` structure used
+with the pip, see `this guide
+<https://kivy-garden.github.io/#guideformigratingflowersfromlegacystructure>`_.
+
+We hope most garden packages will be converted to the newer format to help
+with installation.
+
+General Usage Guidelines
+------------------------
+
+To use a kivy garden flower, first check if the flower is in the legacy format.
+If the flower name is in the format of `garden.flower`, such as
+`garden.graph <https://github.com/kivy-garden/garden.graph>`_ it is a legacy
+flower. If it is just `flower` such as
+`graph <https://github.com/kivy-garden/graph>`_ it is in the present format.
+If it is in the legacy format see `Legacy garden tool instructions`_ for how to
+install and use it. Otherwise, continue with the guide below.
+
+Garden flowers can now be installed with the `pip` tool like a normal python
+package. Given a flower that you want to install, lets use
+`graph <https://github.com/kivy-garden/graph>`_ as an example. You can install
+master directly from github with::
+
+    python -m pip install \
+https://github.com/kivy-garden/graph/archive/master.zip
+
+Look under the repository's releases tab if you'd like to install a specific
+release or a pre-compiled wheel, if the flower has any. Then use the url with
+`pip`.
+
+Or you can automatically install it using garden's pypi server with::
+
+    python -m pip install kivy_garden.graph \
+--extra-index-url https://kivy-garden.github.io/simple/
+
+To permanently add our garden server to your pip configuration so that you
+don't have to specify it with `--extra-index-url`, add::
+
+    [global]
+    timeout = 60
+    index-url = https://kivy-garden.github.io/simple/
+
+to your `pip.conf <https://pip.pypa.io/en/stable/user_guide/#config-file>`_.
+
+If the flower maintainer has uploaded the flower to
+`pypi <https://pypi.org/>`_, you can just install it with
+`pip install kivy_garden.flower`.
+
+
+Legacy garden tool instructions
+-------------------------------
+
+Garden is now distributed as a separate Python module, kivy-garden. You can
+install it with pip::
+
+    pip install kivy-garden
+
+The garden module does not initially include any packages. You can download
+them with the garden tool installed by the pip package::
+
+    # 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
+
+All the garden packages are installed by default in `~/.kivy/garden`.
+
+.. Note:: In previous versions of Kivy, garden was a tool at
+          kivy/tools/garden. This no longer exists, but the
+          kivy-garden module provides exactly the same functionality.
+
+Packaging
+~~~~~~~~~
+
+If you want to include garden packages in your application, you can add `--app`
+to the `install` command. This will create a `libs/garden` directory in your
+current directory which will be used by `kivy.garden`.
+
+For example::
+
+    cd myapp
+    garden install --app graph
+
+
+'''
+
+__path__ = 'kivy.garden'
+
+import sys
+import imp
+from os.path import dirname, join, realpath, exists, abspath
+from kivy import kivy_home_dir
+from kivy.utils import platform
+import kivy
+
+#: system path where garden modules can be installed
+garden_system_dir = join(kivy_home_dir, 'garden')
+garden_kivy_dir = abspath(join(dirname(kivy.__file__), 'garden'))
+
+#: application path where garden modules can be installed
+if getattr(sys, 'frozen', False) and getattr(sys, '_MEIPASS', False):
+    garden_app_dir = join(realpath(sys._MEIPASS), 'libs', 'garden')
+else:
+    garden_app_dir = join(realpath(dirname(sys.argv[0])), 'libs', 'garden')
+#: Fixes issue #4030 in kivy where garden path is incorrect on iOS
+if platform == "ios":
+    from os.path import join, dirname
+    import __main__
+    main_py_file = __main__.__file__
+    garden_app_dir = join(dirname(main_py_file), 'libs', 'garden')
+
+
+class GardenImporter(object):
+
+    def find_module(self, fullname, path):
+        if path == 'kivy.garden':
+            return self
+
+    def load_module(self, fullname):
+        assert(fullname.startswith('kivy.garden'))
+
+        moddir = join(garden_kivy_dir, fullname.split('.', 2)[-1])
+        if exists(moddir):
+            return self._load_module(fullname, moddir)
+
+        modname = fullname.split('.', 1)[-1]
+        for directory in (garden_app_dir, garden_system_dir):
+            moddir = join(directory, modname)
+            if exists(moddir):
+                return self._load_module(fullname, moddir)
+
+    def _load_module(self, fullname, moddir):
+        mod = imp.load_module(fullname, None, moddir,
+                              ('', '', imp.PKG_DIRECTORY))
+        return mod
+
+
+# insert the garden importer as ultimate importer
+sys.meta_path.append(GardenImporter())
diff --git a/kivy/garden/__pycache__/__init__.cpython-310.pyc b/kivy/garden/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..a9a81ad
Binary files /dev/null and b/kivy/garden/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/geometry.py b/kivy/geometry.py
new file mode 100644
index 0000000..4483727
--- /dev/null
+++ b/kivy/geometry.py
@@ -0,0 +1,121 @@
+'''
+Geometry utilities
+==================
+
+This module contains some helper functions for geometric calculations.
+'''
+
+__all__ = ('circumcircle', 'minimum_bounding_circle')
+
+from kivy.vector import Vector
+
+
+def circumcircle(a, b, c):
+    '''
+    Computes the circumcircle of a triangle defined by a, b, c.
+    See: http://en.wikipedia.org/wiki/Circumscribed_circle
+
+    :Parameters:
+        `a`: iterable containing at least 2 values (for x and y)
+            The 1st point of the triangle.
+        `b`: iterable containing at least 2 values (for x and y)
+            The 2nd point of the triangle.
+        `c`: iterable containing at least 2 values (for x and y)
+            The 3rd point of the triangle.
+
+    :Return:
+        A tuple that defines the circle :
+         * The first element in the returned tuple is the center as (x, y)
+         * The second is the radius (float)
+    '''
+    P = Vector(a[0], a[1])
+    Q = Vector(b[0], b[1])
+    R = Vector(c[0], c[1])
+
+    mPQ = (P + Q) * .5
+    mQR = (Q + R) * .5
+
+    numer = -(- mPQ.y * R.y + mPQ.y * Q.y + mQR.y * R.y - mQR.y * Q.y -
+              mPQ.x * R.x + mPQ.x * Q.x + mQR.x * R.x - mQR.x * Q.x)
+    denom = (-Q.x * R.y + P.x * R.y - P.x * Q.y +
+             Q.y * R.x - P.y * R.x + P.y * Q.x)
+
+    t = numer / denom
+
+    cx = -t * (Q.y - P.y) + mPQ.x
+    cy = t * (Q.x - P.x) + mPQ.y
+
+    return ((cx, cy), (P - (cx, cy)).length())
+
+
+def minimum_bounding_circle(points):
+    '''
+    Returns the minimum bounding circle for a set of points.
+
+    For a description of the problem being solved, see the `Smallest Circle
+    Problem <http://en.wikipedia.org/wiki/Smallest_circle_problem>`_.
+
+    The function uses Applet's Algorithm, the runtime is ``O(h^3, *n)``,
+    where h is the number of points in the convex hull of the set of points.
+    **But** it runs in linear time in almost all real world cases.
+    See: http://tinyurl.com/6e4n5yb
+
+    :Parameters:
+        `points`: iterable
+            A list of points (2 tuple with x,y coordinates)
+
+    :Return:
+        A tuple that defines the circle:
+            * The first element in the returned tuple is the center (x, y)
+            * The second the radius (float)
+
+    '''
+    points = [Vector(p[0], p[1]) for p in points]
+
+    if len(points) == 1:
+        return (points[0].x, points[0].y), 0.0
+
+    if len(points) == 2:
+        p1, p2 = points
+        return (p1 + p2) * .5, ((p1 - p2) * .5).length()
+
+    # determine a point P with the smallest y value
+    P = min(points, key=lambda p: p.y)
+
+    # find a point Q such that the angle of the line segment
+    # PQ with the x axis is minimal
+    def x_axis_angle(q):
+        if q == P:
+            return 1e10  # max val if the same, to skip
+        return abs((q - P).angle((1, 0)))
+    Q = min(points, key=x_axis_angle)
+
+    for p in points:
+        # find R such that angle PRQ is minimal
+        def angle_pq(r):
+            if r in (P, Q):
+                return 1e10  # max val if the same, to skip
+            return abs((r - P).angle(r - Q))
+        R = min(points, key=angle_pq)
+
+        # check for case 1 (angle PRQ is obtuse), the circle is determined
+        # by two points, P and Q. radius = |(P-Q)/2|, center = (P+Q)/2
+        if angle_pq(R) > 90.0:
+            return (P + Q) * .5, ((P - Q) * .5).length()
+
+        # if angle RPQ is obtuse, make P = R, and try again
+        if abs((R - P).angle(Q - P)) > 90:
+            P = R
+            continue
+
+        # if angle PQR is obtuse, make Q = R, and try again
+        if abs((P - Q).angle(R - Q)) > 90:
+            Q = R
+            continue
+
+        # all angles were acute..we just need the circle through the
+        # two points furthest apart!
+        break
+
+    # find the circumcenter for triangle given by P,Q,R
+    return circumcircle(P, Q, R)
diff --git a/kivy/gesture.py b/kivy/gesture.py
new file mode 100644
index 0000000..01b90e2
--- /dev/null
+++ b/kivy/gesture.py
@@ -0,0 +1,424 @@
+'''
+Gesture recognition
+===================
+
+This class allows you to easily create new
+gestures and compare them::
+
+    from kivy.gesture import Gesture, GestureDatabase
+
+    # Create a gesture
+    g = Gesture()
+    g.add_stroke(point_list=[(1,1), (3,4), (2,1)])
+    g.normalize()
+
+    # Add it to the database
+    gdb = GestureDatabase()
+    gdb.add_gesture(g)
+
+    # And for the next gesture, try to find it!
+    g2 = Gesture()
+    # ...
+    gdb.find(g2)
+
+.. warning::
+
+   You don't really want to do this: it's more of an example of how
+   to construct gestures dynamically. Typically, you would
+   need a lot more points, so it's better to record gestures in a file and
+   reload them to compare later. Look in the examples/gestures directory for
+   an example of how to do that.
+
+'''
+
+__all__ = ('Gesture', 'GestureDatabase', 'GesturePoint', 'GestureStroke')
+
+import pickle
+import base64
+import zlib
+import math
+
+from kivy.vector import Vector
+
+from io import BytesIO
+
+
+class GestureDatabase(object):
+    '''Class to handle a gesture database.'''
+
+    def __init__(self):
+        self.db = []
+
+    def add_gesture(self, gesture):
+        '''Add a new gesture to the database.'''
+        self.db.append(gesture)
+
+    def find(self, gesture, minscore=0.9, rotation_invariant=True):
+        '''Find a matching gesture in the database.'''
+        if not gesture:
+            return
+
+        best = None
+        bestscore = minscore
+        for g in self.db:
+            score = g.get_score(gesture, rotation_invariant)
+            if score < bestscore:
+                continue
+            bestscore = score
+            best = g
+        if not best:
+            return
+        return (bestscore, best)
+
+    def gesture_to_str(self, gesture):
+        '''Convert a gesture into a unique string.'''
+        io = BytesIO()
+        p = pickle.Pickler(io)
+        p.dump(gesture)
+        data = base64.b64encode(zlib.compress(io.getvalue(), 9))
+        return data
+
+    def str_to_gesture(self, data):
+        '''Convert a unique string to a gesture.'''
+        io = BytesIO(zlib.decompress(base64.b64decode(data)))
+        p = pickle.Unpickler(io)
+        gesture = p.load()
+        return gesture
+
+
+class GesturePoint:
+
+    def __init__(self, x, y):
+        '''Stores the x,y coordinates of a point in the gesture.'''
+        self.x = float(x)
+        self.y = float(y)
+
+    def scale(self, factor):
+        ''' Scales the point by the given factor.'''
+        self.x *= factor
+        self.y *= factor
+        return self
+
+    def __repr__(self):
+        return 'Mouse_point: %f,%f' % (self.x, self.y)
+
+
+class GestureStroke:
+    ''' Gestures can be made up of multiple strokes.'''
+
+    def __init__(self):
+        ''' A stroke in the gesture.'''
+        self.points = list()
+        self.screenpoints = list()
+
+    # These return the min and max coordinates of the stroke
+    @property
+    def max_x(self):
+        if len(self.points) == 0:
+            return 0
+        return max(self.points, key=lambda pt: pt.x).x
+
+    @property
+    def min_x(self):
+        if len(self.points) == 0:
+            return 0
+        return min(self.points, key=lambda pt: pt.x).x
+
+    @property
+    def max_y(self):
+        if len(self.points) == 0:
+            return 0
+        return max(self.points, key=lambda pt: pt.y).y
+
+    @property
+    def min_y(self):
+        if len(self.points) == 0:
+            return 0
+        return min(self.points, key=lambda pt: pt.y).y
+
+    def add_point(self, x, y):
+        '''
+        add_point(x=x_pos, y=y_pos)
+        Adds a point to the stroke.
+        '''
+        self.points.append(GesturePoint(x, y))
+        self.screenpoints.append((x, y))
+
+    def scale_stroke(self, scale_factor):
+        '''
+        scale_stroke(scale_factor=float)
+        Scales the stroke down by scale_factor.
+        '''
+        self.points = [pt.scale(scale_factor) for pt in self.points]
+
+    def points_distance(self, point1, point2):
+        '''
+        points_distance(point1=GesturePoint, point2=GesturePoint)
+        Returns the distance between two GesturePoints.
+        '''
+        x = point1.x - point2.x
+        y = point1.y - point2.y
+        return math.sqrt(x * x + y * y)
+
+    def stroke_length(self, point_list=None):
+        '''Finds the length of the stroke. If a point list is given,
+           finds the length of that list.
+        '''
+        if point_list is None:
+            point_list = self.points
+        gesture_length = 0.0
+        if len(point_list) <= 1:  # If there is only one point -> no length
+            return gesture_length
+        for i in range(len(point_list) - 1):
+            gesture_length += self.points_distance(
+                point_list[i], point_list[i + 1])
+        return gesture_length
+
+    def normalize_stroke(self, sample_points=32):
+        '''Normalizes strokes so that every stroke has a standard number of
+           points. Returns True if stroke is normalized, False if it can't be
+           normalized. sample_points controls the resolution of the stroke.
+        '''
+        # If there is only one point or the length is 0, don't normalize
+        if len(self.points) <= 1 or self.stroke_length(self.points) == 0.0:
+            return False
+
+        # Calculate how long each point should be in the stroke
+        target_stroke_size = \
+            self.stroke_length(self.points) / float(sample_points)
+        new_points = list()
+        new_points.append(self.points[0])
+
+        # We loop on the points
+        prev = self.points[0]
+        src_distance = 0.0
+        dst_distance = target_stroke_size
+        for curr in self.points[1:]:
+            d = self.points_distance(prev, curr)
+            if d > 0:
+                prev = curr
+                src_distance = src_distance + d
+
+                # The new point need to be inserted into the
+                # segment [prev, curr]
+                while dst_distance < src_distance:
+                    x_dir = curr.x - prev.x
+                    y_dir = curr.y - prev.y
+                    ratio = (src_distance - dst_distance) / d
+                    to_x = x_dir * ratio + prev.x
+                    to_y = y_dir * ratio + prev.y
+                    new_points.append(GesturePoint(to_x, to_y))
+                    dst_distance = self.stroke_length(self.points) / \
+                        float(sample_points) * len(new_points)
+
+        # If this happens, we are into troubles...
+        if not len(new_points) == sample_points:
+            raise ValueError('Invalid number of strokes points; got '
+                             '%d while it should be %d' %
+                             (len(new_points), sample_points))
+
+        self.points = new_points
+        return True
+
+    def center_stroke(self, offset_x, offset_y):
+        '''Centers the stroke by offsetting the points.'''
+        for point in self.points:
+            point.x -= offset_x
+            point.y -= offset_y
+
+
+class Gesture:
+    '''A python implementation of a gesture recognition algorithm by
+    Oleg Dopertchouk: http://www.gamedev.net/reference/articles/article2039.asp
+
+    Implemented by Jeiel Aranal (chemikhazi@gmail.com),
+    released into the public domain.
+    '''
+
+    # Tolerance for evaluation using the '==' operator
+    DEFAULT_TOLERANCE = 0.1
+
+    def __init__(self, tolerance=None):
+        '''
+        Gesture([tolerance=float])
+        Creates a new gesture with an optional matching tolerance value.
+        '''
+        self.width = 0.
+        self.height = 0.
+        self.gesture_product = 0.
+        self.strokes = list()
+        if tolerance is None:
+            self.tolerance = Gesture.DEFAULT_TOLERANCE
+        else:
+            self.tolerance = tolerance
+
+    def _scale_gesture(self):
+        ''' Scales down the gesture to a unit of 1.'''
+        # map() creates a list of min/max coordinates of the strokes
+        # in the gesture and min()/max() pulls the lowest/highest value
+        min_x = min([stroke.min_x for stroke in self.strokes])
+        max_x = max([stroke.max_x for stroke in self.strokes])
+        min_y = min([stroke.min_y for stroke in self.strokes])
+        max_y = max([stroke.max_y for stroke in self.strokes])
+        x_len = max_x - min_x
+        self.width = x_len
+        y_len = max_y - min_y
+        self.height = y_len
+        scale_factor = max(x_len, y_len)
+        if scale_factor <= 0.0:
+            return False
+        scale_factor = 1.0 / scale_factor
+        for stroke in self.strokes:
+            stroke.scale_stroke(scale_factor)
+        return True
+
+    def _center_gesture(self):
+        ''' Centers the Gesture.points of the gesture.'''
+        total_x = 0.0
+        total_y = 0.0
+        total_points = 0
+
+        for stroke in self.strokes:
+            # adds up all the points inside the stroke
+            stroke_y = sum([pt.y for pt in stroke.points])
+            stroke_x = sum([pt.x for pt in stroke.points])
+            total_y += stroke_y
+            total_x += stroke_x
+            total_points += len(stroke.points)
+        if total_points == 0:
+            return False
+        # Average to get the offset
+        total_x /= total_points
+        total_y /= total_points
+        # Apply the offset to the strokes
+        for stroke in self.strokes:
+            stroke.center_stroke(total_x, total_y)
+        return True
+
+    def add_stroke(self, point_list=None):
+        '''Adds a stroke to the gesture and returns the Stroke instance.
+           Optional point_list argument is a list of the mouse points for
+           the stroke.
+        '''
+        self.strokes.append(GestureStroke())
+        if isinstance(point_list, list) or isinstance(point_list, tuple):
+            for point in point_list:
+                if isinstance(point, GesturePoint):
+                    self.strokes[-1].points.append(point)
+                elif isinstance(point, list) or isinstance(point, tuple):
+                    if len(point) != 2:
+                        raise ValueError("Stroke entry must have 2 values max")
+                    self.strokes[-1].add_point(point[0], point[1])
+                else:
+                    raise TypeError("The point list should either be "
+                                    "tuples of x and y or a list of "
+                                    "GesturePoint objects")
+        elif point_list is not None:
+            raise ValueError("point_list should be a tuple/list")
+        return self.strokes[-1]
+
+    def normalize(self, stroke_samples=32):
+        '''Runs the gesture normalization algorithm and calculates the dot
+        product with self.
+        '''
+        if not self._scale_gesture() or not self._center_gesture():
+            self.gesture_product = False
+            return False
+        for stroke in self.strokes:
+            stroke.normalize_stroke(stroke_samples)
+        self.gesture_product = self.dot_product(self)
+
+    def get_rigid_rotation(self, dstpts):
+        '''
+        Extract the rotation to apply to a group of points to minimize the
+        distance to a second group of points. The two groups of points are
+        assumed to be centered. This is a simple version that just picks
+        an angle based on the first point of the gesture.
+        '''
+        if len(self.strokes) < 1 or len(self.strokes[0].points) < 1:
+            return 0
+        if len(dstpts.strokes) < 1 or len(dstpts.strokes[0].points) < 1:
+            return 0
+        p = dstpts.strokes[0].points[0]
+        target = Vector([p.x, p.y])
+        source = Vector([p.x, p.y])
+        return source.angle(target)
+
+    def dot_product(self, comparison_gesture):
+        ''' Calculates the dot product of the gesture with another gesture.'''
+        if len(comparison_gesture.strokes) != len(self.strokes):
+            return -1
+        if getattr(comparison_gesture, 'gesture_product', True) is False or \
+           getattr(self, 'gesture_product', True) is False:
+            return -1
+        dot_product = 0.0
+        for stroke_index, (my_stroke, cmp_stroke) in enumerate(
+                list(zip(self.strokes, comparison_gesture.strokes))):
+            for pt_index, (my_point, cmp_point) in enumerate(
+                    list(zip(my_stroke.points, cmp_stroke.points))):
+                dot_product += (my_point.x * cmp_point.x +
+                                my_point.y * cmp_point.y)
+        return dot_product
+
+    def rotate(self, angle):
+        g = Gesture()
+        for stroke in self.strokes:
+            tmp = []
+            for j in stroke.points:
+                v = Vector([j.x, j.y]).rotate(angle)
+                tmp.append(v)
+            g.add_stroke(tmp)
+        g.gesture_product = g.dot_product(g)
+        return g
+
+    def get_score(self, comparison_gesture, rotation_invariant=True):
+        ''' Returns the matching score of the gesture against another gesture.
+        '''
+        if isinstance(comparison_gesture, Gesture):
+            if rotation_invariant:
+                # get orientation
+                angle = self.get_rigid_rotation(comparison_gesture)
+
+                # rotate the gesture to be in the same frame.
+                comparison_gesture = comparison_gesture.rotate(angle)
+
+            # this is the normal "orientation" code.
+            score = self.dot_product(comparison_gesture)
+            if score <= 0:
+                return score
+            score /= math.sqrt(
+                self.gesture_product * comparison_gesture.gesture_product)
+            return score
+
+    def __eq__(self, comparison_gesture):
+        ''' Allows easy comparisons between gesture instances.'''
+        if isinstance(comparison_gesture, Gesture):
+            # If the gestures don't have the same number of strokes, its
+            # definitely not the same gesture
+            score = self.get_score(comparison_gesture)
+            if (score > (1.0 - self.tolerance) and
+                    score < (1.0 + self.tolerance)):
+                return True
+            else:
+                return False
+        else:
+            return NotImplemented
+
+    def __ne__(self, comparison_gesture):
+        result = self.__eq__(comparison_gesture)
+        if result is NotImplemented:
+            return result
+        else:
+            return not result
+
+    def __lt__(self, comparison_gesture):
+        raise TypeError("Gesture cannot be evaluated with <")
+
+    def __gt__(self, comparison_gesture):
+        raise TypeError("Gesture cannot be evaluated with >")
+
+    def __le__(self, comparison_gesture):
+        raise TypeError("Gesture cannot be evaluated with <=")
+
+    def __ge__(self, comparison_gesture):
+        raise TypeError("Gesture cannot be evaluated with >=")
diff --git a/kivy/graphics/__init__.py b/kivy/graphics/__init__.py
new file mode 100644
index 0000000..40704f3
--- /dev/null
+++ b/kivy/graphics/__init__.py
@@ -0,0 +1,121 @@
+'''
+Graphics
+========
+
+This package assembles many low level functions used for drawing. The whole
+graphics package is compatible with OpenGL ES 2.0 and has many rendering
+optimizations.
+
+The basics
+----------
+
+For drawing on a screen, you will need :
+
+    1. a :class:`~kivy.graphics.instructions.Canvas` object.
+    2. :class:`~kivy.graphics.instructions.Instruction` objects.
+
+Each :class:`~kivy.uix.widget.Widget`
+in Kivy already has a :class:`Canvas` by default. When you create
+a widget, you can create all the instructions needed for drawing. If
+`self` is your current widget, you can do::
+
+    from kivy.graphics import *
+    with self.canvas:
+        # Add a red color
+        Color(1., 0, 0)
+
+        # Add a rectangle
+        Rectangle(pos=(10, 10), size=(500, 500))
+
+The instructions :class:`Color` and :class:`Rectangle` are automatically added
+to the canvas object and will be used when the window is drawn.
+
+.. note::
+
+    Kivy drawing instructions are not automatically relative to the position
+    or size of the widget. You, therefore, need to consider these factors when
+    drawing. In order to make your drawing instructions relative to the widget,
+    the instructions need either to be
+    declared in the :mod:`KvLang <kivy.lang>` or bound to pos and size changes.
+    Please see :ref:`adding_widget_background` for more detail.
+
+GL Reloading mechanism
+----------------------
+
+.. versionadded:: 1.2.0
+
+During the lifetime of the application, the OpenGL context might be lost. This
+happens:
+
+- when the window is resized on OS X or the Windows platform and you're
+  using pygame as a window provider. This is due to SDL 1.2. In the SDL 1.2
+  design, it needs to recreate a GL context everytime the window is
+  resized. This was fixed in SDL 1.3 but pygame is not yet available on it
+  by default.
+
+- when Android releases the app resources: when your application goes to the
+  background, Android might reclaim your opengl context to give the
+  resource to another app. When the user switches back to your application, a
+  newly created gl context is given to your app.
+
+Starting from 1.2.0, we have introduced a mechanism for reloading all the
+graphics resources using the GPU: Canvas, FBO, Shader, Texture, VBO,
+and VertexBatch:
+
+- VBO and VertexBatch are constructed by our graphics instructions. We have all
+  the data needed to reconstruct when reloading.
+
+- Shader: same as VBO, we store the source and values used in the
+  shader so we are able to recreate the vertex/fragment/program.
+
+- Texture: if the texture has a source (an image file or atlas), the image
+  is reloaded from the source and reuploaded to the GPU.
+
+You should cover these cases yourself:
+
+- Textures without a source: if you manually created a texture and manually
+  blit data / a buffer to it, you must handle the reloading yourself. Check the
+  :doc:`api-kivy.graphics.texture` to learn how to manage that case. (The text
+  rendering already generates the texture and handles the reloading. You
+  don't need to reload text yourself.)
+
+- FBO: if you added / removed / drew things multiple times on the FBO, we
+  can't reload it. We don't keep a history of the instructions put on it.
+  As for textures without a source, check the :doc:`api-kivy.graphics.fbo` to
+  learn how to manage that case.
+
+'''
+
+from kivy.graphics.instructions import Callback, Canvas, CanvasBase, \
+    ContextInstruction, Instruction, InstructionGroup, RenderContext, \
+    VertexInstruction
+from kivy.graphics.context_instructions import BindTexture, Color, \
+    PushState, ChangeState, PopState, MatrixInstruction, ApplyContextMatrix, \
+    PopMatrix, PushMatrix, Rotate, Scale, Translate, LoadIdentity, \
+    UpdateNormalMatrix, gl_init_resources
+from kivy.graphics.vertex_instructions import Bezier, BorderImage, Ellipse, \
+    GraphicException, Line, Mesh, Point, Quad, Rectangle, RoundedRectangle, \
+    Triangle, SmoothLine
+from kivy.graphics.stencil_instructions import StencilPop, StencilPush, \
+    StencilUse, StencilUnUse
+from kivy.graphics.gl_instructions import ClearColor, ClearBuffers
+from kivy.graphics.fbo import Fbo
+from kivy.graphics.scissor_instructions import ScissorPush, ScissorPop
+
+# very hacky way to avoid pyflakes warning...
+__all__ = (Bezier.__name__, BindTexture.__name__, BorderImage.__name__,
+           Callback.__name__, Canvas.__name__, CanvasBase.__name__,
+           Color.__name__, ContextInstruction.__name__,
+           Ellipse.__name__, Fbo.__name__, GraphicException.__name__,
+           Instruction.__name__, InstructionGroup.__name__,
+           Line.__name__, SmoothLine.__name__, MatrixInstruction.__name__,
+           Mesh.__name__, Point.__name__, PopMatrix.__name__,
+           PushMatrix.__name__, Quad.__name__, Rectangle.__name__,
+           RenderContext.__name__, Rotate.__name__, Scale.__name__,
+           StencilPop.__name__, StencilPush.__name__, StencilUse.__name__,
+           StencilUnUse.__name__, Translate.__name__, Triangle.__name__,
+           VertexInstruction.__name__, ClearColor.__name__,
+           ClearBuffers.__name__, gl_init_resources.__name__,
+           PushState.__name__, ChangeState.__name__, PopState.__name__,
+           ApplyContextMatrix.__name__, UpdateNormalMatrix.__name__,
+           LoadIdentity.__name__)
diff --git a/kivy/graphics/__pycache__/__init__.cpython-310.pyc b/kivy/graphics/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..b49a9c4
Binary files /dev/null and b/kivy/graphics/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/graphics/buffer.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/buffer.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..625f880
Binary files /dev/null and b/kivy/graphics/buffer.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/buffer.pxd b/kivy/graphics/buffer.pxd
new file mode 100644
index 0000000..9824795
--- /dev/null
+++ b/kivy/graphics/buffer.pxd
@@ -0,0 +1,17 @@
+cdef class Buffer:
+    cdef void *data
+    cdef int *l_free
+    cdef int i_free
+    cdef long block_size
+    cdef long block_count
+
+    cdef void clear(self)
+    cdef void grow(self, long block_count)
+    cdef void add(self, void *blocks, unsigned short *indices, int count)
+    cdef void remove(self, unsigned short *indices, int count)
+    cdef int count(self)
+    cdef long size(self)
+    cdef void *pointer(self)
+    cdef void *offset_pointer(self, int offset)
+    cdef void update(self, int index, void* blocks, int count)
+
diff --git a/kivy/graphics/cgl.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/cgl.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..b8f4581
Binary files /dev/null and b/kivy/graphics/cgl.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/cgl.h b/kivy/graphics/cgl.h
new file mode 100644
index 0000000..4259136
--- /dev/null
+++ b/kivy/graphics/cgl.h
@@ -0,0 +1,35 @@
+/* Generated by Cython 0.29.28 */
+
+#ifndef __PYX_HAVE__kivy__graphics__cgl
+#define __PYX_HAVE__kivy__graphics__cgl
+
+#include "Python.h"
+
+#ifndef __PYX_HAVE_API__kivy__graphics__cgl
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#ifndef DL_IMPORT
+  #define DL_IMPORT(_T) _T
+#endif
+
+__PYX_EXTERN_C int verify_gl_main_thread;
+
+#endif /* !__PYX_HAVE_API__kivy__graphics__cgl */
+
+/* WARNING: the interface of the module init function changed in CPython 3.5. */
+/* It now returns a PyModuleDef instance instead of a PyModule instance. */
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC initcgl(void);
+#else
+PyMODINIT_FUNC PyInit_cgl(void);
+#endif
+
+#endif /* !__PYX_HAVE__kivy__graphics__cgl */
diff --git a/kivy/graphics/cgl.pxd b/kivy/graphics/cgl.pxd
new file mode 100644
index 0000000..b3d7e4e
--- /dev/null
+++ b/kivy/graphics/cgl.pxd
@@ -0,0 +1,650 @@
+include "common.pxi"
+include "../include/config.pxi"
+
+
+cdef extern from "gl_redirect.h":
+
+    ctypedef void               GLvoid
+    ctypedef char               GLchar
+    ctypedef unsigned int       GLenum
+    ctypedef unsigned char      GLboolean
+    ctypedef unsigned int       GLbitfield
+    ctypedef short              GLshort
+    ctypedef int                GLint
+    ctypedef int                GLsizei
+    ctypedef unsigned short     GLushort
+    ctypedef unsigned int       GLuint
+    ctypedef signed char        GLbyte
+    ctypedef unsigned char      GLubyte
+    ctypedef float              GLfloat
+    ctypedef float              GLclampf
+    ctypedef int                GLfixed
+    ctypedef signed long int    GLintptr
+    ctypedef signed long int    GLsizeiptr
+
+
+    int GL_DEPTH_BUFFER_BIT
+    int GL_STENCIL_BUFFER_BIT
+    int GL_COLOR_BUFFER_BIT
+
+    int GL_FALSE
+    int GL_TRUE
+
+    int GL_POINTS
+    int GL_LINES
+    int GL_LINE_LOOP
+    int GL_LINE_STRIP
+    int GL_TRIANGLES
+    int GL_TRIANGLE_STRIP
+    int GL_TRIANGLE_FAN
+
+    int GL_ZERO
+    int GL_ONE
+    int GL_SRC_COLOR
+    int GL_ONE_MINUS_SRC_COLOR
+    int GL_SRC_ALPHA
+    int GL_ONE_MINUS_SRC_ALPHA
+    int GL_DST_ALPHA
+    int GL_ONE_MINUS_DST_ALPHA
+
+    int GL_DST_COLOR
+    int GL_ONE_MINUS_DST_COLOR
+    int GL_SRC_ALPHA_SATURATE
+
+    int GL_FUNC_ADD
+    int GL_BLEND_EQUATION
+    int GL_BLEND_EQUATION_RGB
+    int GL_BLEND_EQUATION_ALPHA
+
+    int GL_FUNC_SUBTRACT
+    int GL_FUNC_REVERSE_SUBTRACT
+
+    int GL_BLEND_DST_RGB
+    int GL_BLEND_SRC_RGB
+    int GL_BLEND_DST_ALPHA
+    int GL_BLEND_SRC_ALPHA
+    int GL_ANT_COLOR
+    int GL_ONE_MINUS_ANT_COLOR
+    int GL_ANT_ALPHA
+    int GL_ONE_MINUS_ANT_ALPHA
+    int GL_BLEND_COLOR
+
+    int GL_ARRAY_BUFFER
+    int GL_ELEMENT_ARRAY_BUFFER
+    int GL_ARRAY_BUFFER_BINDING
+    int GL_ELEMENT_ARRAY_BUFFER_BINDING
+
+    int GL_STREAM_DRAW
+    int GL_STATIC_DRAW
+    int GL_DYNAMIC_DRAW
+
+    int GL_BUFFER_SIZE
+    int GL_BUFFER_USAGE
+
+    int GL_CURRENT_VERTEX_ATTRIB
+
+    int GL_FRONT
+    int GL_BACK
+    int GL_FRONT_AND_BACK
+
+    int GL_TEXTURE_2D
+    int GL_CULL_FACE
+    int GL_BLEND
+    int GL_DITHER
+    int GL_STENCIL_TEST
+    int GL_DEPTH_TEST
+    int GL_SCISSOR_TEST
+    int GL_POLYGON_OFFSET_FILL
+    int GL_SAMPLE_ALPHA_TO_COVERAGE
+    int GL_SAMPLE_COVERAGE
+
+    int GL_NO_ERROR
+    int GL_INVALID_ENUM
+    int GL_INVALID_VALUE
+    int GL_INVALID_OPERATION
+    int GL_OUT_OF_MEMORY
+
+    int GL_CW
+    int GL_CCW
+
+    int GL_LINE_WIDTH
+    int GL_ALIASED_POINT_SIZE_RANGE
+    int GL_ALIASED_LINE_WIDTH_RANGE
+    int GL_CULL_FACE_MODE
+    int GL_FRONT_FACE
+    int GL_DEPTH_RANGE
+    int GL_DEPTH_WRITEMASK
+    int GL_DEPTH_CLEAR_VALUE
+    int GL_DEPTH_FUNC
+    int GL_STENCIL_CLEAR_VALUE
+    int GL_STENCIL_FUNC
+    int GL_STENCIL_FAIL
+    int GL_STENCIL_PASS_DEPTH_FAIL
+    int GL_STENCIL_PASS_DEPTH_PASS
+    int GL_STENCIL_REF
+    int GL_STENCIL_VALUE_MASK
+    int GL_STENCIL_WRITEMASK
+    int GL_STENCIL_BACK_FUNC
+    int GL_STENCIL_BACK_FAIL
+    int GL_STENCIL_BACK_PASS_DEPTH_FAIL
+    int GL_STENCIL_BACK_PASS_DEPTH_PASS
+    int GL_STENCIL_BACK_REF
+    int GL_STENCIL_BACK_VALUE_MASK
+    int GL_STENCIL_BACK_WRITEMASK
+    int GL_VIEWPORT
+    int GL_SCISSOR_BOX
+
+    int GL_COLOR_CLEAR_VALUE
+    int GL_COLOR_WRITEMASK
+    int GL_UNPACK_ALIGNMENT
+    int GL_PACK_ALIGNMENT
+    int GL_MAX_TEXTURE_SIZE
+    int GL_MAX_VIEWPORT_DIMS
+    int GL_SUBPIXEL_BITS
+    int GL_RED_BITS
+    int GL_GREEN_BITS
+    int GL_BLUE_BITS
+    int GL_ALPHA_BITS
+    int GL_DEPTH_BITS
+    int GL_STENCIL_BITS
+    int GL_POLYGON_OFFSET_UNITS
+
+    int GL_POLYGON_OFFSET_FACTOR
+    int GL_TEXTURE_BINDING_2D
+    int GL_SAMPLE_BUFFERS
+    int GL_SAMPLES
+    int GL_SAMPLE_COVERAGE_VALUE
+    int GL_SAMPLE_COVERAGE_INVERT
+
+    int GL_NUM_COMPRESSED_TEXTURE_FORMATS
+    int GL_COMPRESSED_TEXTURE_FORMATS
+
+    int GL_DONT_CARE
+    int GL_FASTEST
+    int GL_NICEST
+
+    int GL_GENERATE_MIPMAP_HINT
+
+    int GL_BYTE
+    int GL_UNSIGNED_BYTE
+    int GL_SHORT
+    int GL_UNSIGNED_SHORT
+    int GL_INT
+    int GL_UNSIGNED_INT
+    int GL_FLOAT
+
+    int GL_DEPTH_COMPONENT
+    int GL_ALPHA
+    int GL_RGB
+    int GL_RGBA
+    int GL_LUMINANCE
+    int GL_LUMINANCE_ALPHA
+
+    int GL_UNSIGNED_SHORT_4_4_4_4
+    int GL_UNSIGNED_SHORT_5_5_5_1
+    int GL_UNSIGNED_SHORT_5_6_5
+
+    int GL_FRAGMENT_SHADER
+    int GL_VERTEX_SHADER
+    int GL_MAX_VERTEX_ATTRIBS
+    int GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
+    int GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
+    int GL_MAX_TEXTURE_IMAGE_UNITS
+    int GL_SHADER_TYPE
+    int GL_DELETE_STATUS
+    int GL_LINK_STATUS
+    int GL_VALIDATE_STATUS
+    int GL_ATTACHED_SHADERS
+    int GL_ACTIVE_UNIFORMS
+    int GL_ACTIVE_UNIFORM_MAX_LENGTH
+    int GL_ACTIVE_ATTRIBUTES
+    int GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
+    int GL_SHADING_LANGUAGE_VERSION
+    int GL_CURRENT_PROGRAM
+
+    int GL_NEVER
+    int GL_LESS
+    int GL_EQUAL
+    int GL_LEQUAL
+    int GL_GREATER
+    int GL_NOTEQUAL
+    int GL_GEQUAL
+    int GL_ALWAYS
+
+    int GL_KEEP
+    int GL_REPLACE
+    int GL_INCR
+    int GL_DECR
+    int GL_INVERT
+    int GL_INCR_WRAP
+    int GL_DECR_WRAP
+
+    int GL_VENDOR
+    int GL_RENDERER
+    int GL_VERSION
+    int GL_EXTENSIONS
+
+    int GL_NEAREST
+    int GL_LINEAR
+
+    int GL_NEAREST_MIPMAP_NEAREST
+    int GL_LINEAR_MIPMAP_NEAREST
+    int GL_NEAREST_MIPMAP_LINEAR
+    int GL_LINEAR_MIPMAP_LINEAR
+
+    int GL_TEXTURE_MAG_FILTER
+    int GL_TEXTURE_MIN_FILTER
+    int GL_TEXTURE_WRAP_S
+    int GL_TEXTURE_WRAP_T
+
+    int GL_TEXTURE
+
+    int GL_TEXTURE_CUBE_MAP
+    int GL_TEXTURE_BINDING_CUBE_MAP
+    int GL_TEXTURE_CUBE_MAP_POSITIVE_X
+    int GL_TEXTURE_CUBE_MAP_NEGATIVE_X
+    int GL_TEXTURE_CUBE_MAP_POSITIVE_Y
+    int GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
+    int GL_TEXTURE_CUBE_MAP_POSITIVE_Z
+    int GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+    int GL_MAX_CUBE_MAP_TEXTURE_SIZE
+
+    int GL_TEXTURE0
+    int GL_TEXTURE1
+    int GL_TEXTURE2
+    int GL_TEXTURE3
+    int GL_TEXTURE4
+    int GL_TEXTURE5
+    int GL_TEXTURE6
+    int GL_TEXTURE7
+    int GL_TEXTURE8
+    int GL_TEXTURE9
+    int GL_TEXTURE10
+    int GL_TEXTURE11
+    int GL_TEXTURE12
+    int GL_TEXTURE13
+    int GL_TEXTURE14
+    int GL_TEXTURE15
+    int GL_TEXTURE16
+    int GL_TEXTURE17
+    int GL_TEXTURE18
+    int GL_TEXTURE19
+    int GL_TEXTURE20
+    int GL_TEXTURE21
+    int GL_TEXTURE22
+    int GL_TEXTURE23
+    int GL_TEXTURE24
+    int GL_TEXTURE25
+    int GL_TEXTURE26
+    int GL_TEXTURE27
+    int GL_TEXTURE28
+    int GL_TEXTURE29
+    int GL_TEXTURE30
+    int GL_TEXTURE31
+    int GL_ACTIVE_TEXTURE
+
+
+    int GL_REPEAT
+    int GL_CLAMP_TO_EDGE
+    int GL_MIRRORED_REPEAT
+
+    int GL_FLOAT_VEC2
+    int GL_FLOAT_VEC3
+    int GL_FLOAT_VEC4
+    int GL_INT_VEC2
+    int GL_INT_VEC3
+    int GL_INT_VEC4
+    int GL_BOOL
+    int GL_BOOL_VEC2
+    int GL_BOOL_VEC3
+    int GL_BOOL_VEC4
+    int GL_FLOAT_MAT2
+    int GL_FLOAT_MAT3
+    int GL_FLOAT_MAT4
+    int GL_SAMPLER_2D
+    int GL_SAMPLER_CUBE
+
+    int GL_VERTEX_ATTRIB_ARRAY_ENABLED
+    int GL_VERTEX_ATTRIB_ARRAY_SIZE
+    int GL_VERTEX_ATTRIB_ARRAY_STRIDE
+    int GL_VERTEX_ATTRIB_ARRAY_TYPE
+    int GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
+    int GL_VERTEX_ATTRIB_ARRAY_POINTER
+    int GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
+
+    int GL_COMPILE_STATUS
+    int GL_INFO_LOG_LENGTH
+    int GL_SHADER_SOURCE_LENGTH
+
+    int GL_SHADER_BINARY_FORMATS
+
+    int GL_FRAMEBUFFER
+    int GL_RENDERBUFFER
+
+    int GL_RGBA4
+    int GL_RGB5_A1
+    int GL_RGB565
+    int GL_DEPTH_COMPONENT16
+    int GL_STENCIL_INDEX8
+    int GL_DEPTH24_STENCIL8_OES
+
+    int GL_RENDERBUFFER_WIDTH
+    int GL_RENDERBUFFER_HEIGHT
+    int GL_RENDERBUFFER_INTERNAL_FORMAT
+    int GL_RENDERBUFFER_RED_SIZE
+    int GL_RENDERBUFFER_GREEN_SIZE
+    int GL_RENDERBUFFER_BLUE_SIZE
+    int GL_RENDERBUFFER_ALPHA_SIZE
+    int GL_RENDERBUFFER_DEPTH_SIZE
+    int GL_RENDERBUFFER_STENCIL_SIZE
+
+    int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
+    int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
+    int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL
+    int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
+
+    int GL_COLOR_ATTACHMENT0
+    int GL_DEPTH_ATTACHMENT
+    int GL_STENCIL_ATTACHMENT
+
+    int GL_NONE
+
+    int GL_FRAMEBUFFER_COMPLETE
+    int GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
+    int GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
+    int GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS
+    int GL_FRAMEBUFFER_UNSUPPORTED
+
+    int GL_FRAMEBUFFER_BINDING
+    int GL_RENDERBUFFER_BINDING
+    int GL_MAX_RENDERBUFFER_SIZE
+
+    int GL_INVALID_FRAMEBUFFER_OPERATION
+
+    int GL_FIXED
+    int GL_MAX_VERTEX_UNIFORM_VECTORS
+    int GL_MAX_VARYING_VECTORS
+    int GL_MAX_FRAGMENT_UNIFORM_VECTORS
+    int GL_IMPLEMENTATION_COLOR_READ_TYPE
+    int GL_IMPLEMENTATION_COLOR_READ_FORMAT
+    int GL_SHADER_COMPILER
+    int GL_NUM_SHADER_BINARY_FORMATS
+    int GL_LOW_FLOAT
+    int GL_MEDIUM_FLOAT
+    int GL_HIGH_FLOAT
+    int GL_LOW_INT
+    int GL_MEDIUM_INT
+    int GL_HIGH_INT
+
+    int GL_FRAMEBUFFER_UNDEFINED_OES
+
+ctypedef const GLubyte* (__stdcall *GLGETSTRINGPTR)(GLenum) nogil
+ctypedef GLboolean (__stdcall *GLISBUFFERPTR)(GLuint buffer) nogil
+ctypedef GLboolean (__stdcall *GLISENABLEDPTR)(GLenum cap) nogil
+ctypedef GLboolean (__stdcall *GLISFRAMEBUFFERPTR)(GLuint framebuffer) nogil
+ctypedef GLboolean (__stdcall *GLISPROGRAMPTR)(GLuint program) nogil
+ctypedef GLboolean (__stdcall *GLISRENDERBUFFERPTR)(GLuint renderbuffer) nogil
+ctypedef GLboolean (__stdcall *GLISSHADERPTR)(GLuint shader) nogil
+ctypedef GLboolean (__stdcall *GLISTEXTUREPTR)(GLuint texture) nogil
+ctypedef GLenum (__stdcall *GLCHECKFRAMEBUFFERSTATUSPTR)(GLenum) nogil
+ctypedef GLenum (__stdcall *GLGETERRORPTR)() nogil
+ctypedef GLint (__stdcall *GLGETATTRIBLOCATIONPTR)(GLuint, const GLchar *) nogil
+ctypedef GLint (__stdcall *GLGETUNIFORMLOCATIONPTR)(GLuint, const char *) nogil
+ctypedef GLuint (__stdcall *GLCREATEPROGRAMPTR)() nogil
+ctypedef GLuint (__stdcall *GLCREATESHADERPTR)(GLenum) nogil
+ctypedef void (__stdcall *GLACTIVETEXTUREPTR)(GLenum) nogil
+ctypedef void (__stdcall *GLATTACHSHADERPTR)(GLuint, GLuint) nogil
+ctypedef void (__stdcall *GLBINDATTRIBLOCATIONPTR)(GLuint, GLuint, const char *) nogil
+ctypedef void (__stdcall *GLBINDBUFFERPTR)(GLenum, GLuint) nogil
+ctypedef void (__stdcall *GLBINDFRAMEBUFFERPTR)(GLenum, GLuint) nogil
+ctypedef void (__stdcall *GLBINDRENDERBUFFERPTR)(GLenum target, GLuint renderbuffer) nogil
+ctypedef void (__stdcall *GLBINDTEXTUREPTR)(GLenum, GLuint) nogil
+ctypedef void (__stdcall *GLBLENDCOLORPTR)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) nogil
+ctypedef void (__stdcall *GLBLENDEQUATIONPTR)( GLenum mode ) nogil
+ctypedef void (__stdcall *GLBLENDEQUATIONSEPARATEPTR)(GLenum modeRGB, GLenum modeAlpha) nogil
+ctypedef void (__stdcall *GLBLENDFUNCPTR)(GLenum sfactor, GLenum dfactor) nogil
+ctypedef void (__stdcall *GLBLENDFUNCSEPARATEPTR)(GLenum, GLenum, GLenum, GLenum) nogil
+ctypedef void (__stdcall *GLBUFFERDATAPTR)(GLenum, GLsizeiptr, const GLvoid *, GLenum) nogil
+ctypedef void (__stdcall *GLBUFFERSUBDATAPTR)(GLenum, GLintptr, GLsizeiptr, const GLvoid *) nogil
+ctypedef void (__stdcall *GLCLEARCOLORPTR)(GLclampf, GLclampf, GLclampf, GLclampf) nogil
+ctypedef void (__stdcall *GLCLEARPTR)(GLbitfield) nogil
+ctypedef void (__stdcall *GLCLEARSTENCILPTR)(GLint s) nogil
+ctypedef void (__stdcall *GLCOLORMASKPTR)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) nogil
+ctypedef void (__stdcall *GLCOMPILESHADERPTR)(GLuint) nogil
+ctypedef void (__stdcall *GLCOMPRESSEDTEXIMAGE2DPTR)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) nogil
+ctypedef void (__stdcall *GLCOMPRESSEDTEXSUBIMAGE2DPTR)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) nogil
+ctypedef void (__stdcall *GLCOPYTEXIMAGE2DPTR)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) nogil
+ctypedef void (__stdcall *GLCOPYTEXSUBIMAGE2DPTR)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) nogil
+ctypedef void (__stdcall *GLCULLFACEPTR)(GLenum mode) nogil
+ctypedef void (__stdcall *GLDELETEBUFFERSPTR)(GLsizei n, const GLuint* buffers) nogil
+ctypedef void (__stdcall *GLDELETEFRAMEBUFFERSPTR)(GLsizei, const GLuint *) nogil
+ctypedef void (__stdcall *GLDELETEPROGRAMPTR)(GLuint) nogil
+ctypedef void (__stdcall *GLDELETERENDERBUFFERSPTR)(GLsizei n, const GLuint* renderbuffers) nogil
+ctypedef void (__stdcall *GLDELETESHADERPTR)(GLuint) nogil
+ctypedef void (__stdcall *GLDELETETEXTURESPTR)(GLsizei, const GLuint *) nogil
+ctypedef void (__stdcall *GLDEPTHFUNCPTR)(GLenum func) nogil
+ctypedef void (__stdcall *GLDEPTHMASKPTR)(GLboolean flag) nogil
+ctypedef void (__stdcall *GLDETACHSHADERPTR)(GLuint program, GLuint shader) nogil
+ctypedef void (__stdcall *GLDISABLEPTR)(GLenum) nogil
+ctypedef void (__stdcall *GLDISABLEVERTEXATTRIBARRAYPTR)(GLuint) nogil
+ctypedef void (__stdcall *GLDRAWARRAYSPTR)(GLenum, GLint, GLsizei) nogil
+ctypedef void (__stdcall *GLDRAWELEMENTSPTR)(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) nogil
+ctypedef void (__stdcall *GLENABLEPTR)(GLenum) nogil
+ctypedef void (__stdcall *GLENABLEVERTEXATTRIBARRAYPTR)(GLuint) nogil
+ctypedef void (__stdcall *GLFINISHPTR)() nogil
+ctypedef void (__stdcall *GLFLUSHPTR)() nogil
+ctypedef void (__stdcall *GLFRAMEBUFFERRENDERBUFFERPTR)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) nogil
+ctypedef void (__stdcall *GLFRAMEBUFFERTEXTURE2DPTR)(GLenum, GLenum, GLenum, GLuint, GLint) nogil
+ctypedef void (__stdcall *GLFRONTFACEPTR)(GLenum mode) nogil
+ctypedef void (__stdcall *GLGENBUFFERSPTR)(GLsizei, GLuint *) nogil
+ctypedef void (__stdcall *GLGENERATEMIPMAPPTR)(GLenum target) nogil
+ctypedef void (__stdcall *GLGENFRAMEBUFFERSPTR)(GLsizei, GLuint *) nogil
+ctypedef void (__stdcall *GLGENRENDERBUFFERSPTR)(GLsizei n, GLuint* renderbuffers) nogil
+ctypedef void (__stdcall *GLGENTEXTURESPTR)(GLsizei, GLuint *) nogil
+ctypedef void (__stdcall *GLGETACTIVEATTRIBPTR)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) nogil
+ctypedef void (__stdcall *GLGETACTIVEUNIFORMPTR)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) nogil
+ctypedef void (__stdcall *GLGETATTACHEDSHADERSPTR)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) nogil
+ctypedef void (__stdcall *GLGETBOOLEANVPTR)(GLenum, GLboolean *) nogil
+ctypedef void (__stdcall *GLGETBUFFERPARAMETERIVPTR)(GLenum target, GLenum pname, GLint* params) nogil
+ctypedef void (__stdcall *GLGETFLOATVPTR)(GLenum pname, GLfloat* params) nogil
+ctypedef void (__stdcall *GLGETFRAMEBUFFERATTACHMENTPARAMETERIVPTR)(GLenum target, GLenum attachment, GLenum pname, GLint* params) nogil
+ctypedef void (__stdcall *GLGETINTEGERVPTR)(GLenum, GLint *) nogil
+ctypedef void (__stdcall *GLGETPROGRAMINFOLOGPTR)(GLuint, GLsizei, GLsizei*, GLchar*) nogil
+ctypedef void (__stdcall *GLGETPROGRAMIVPTR)(GLuint, GLenum, GLint *) nogil
+ctypedef void (__stdcall *GLGETRENDERBUFFERPARAMETERIVPTR)(GLenum target, GLenum pname, GLint* params) nogil
+ctypedef void (__stdcall *GLGETSHADERINFOLOGPTR)(GLuint, GLsizei, GLsizei *, char *) nogil
+ctypedef void (__stdcall *GLGETSHADERIVPTR)(GLuint, GLenum, GLint *) nogil
+ctypedef void (__stdcall *GLGETSHADERSOURCEPTR)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) nogil
+ctypedef void (__stdcall *GLGETTEXPARAMETERFVPTR)(GLenum target, GLenum pname, GLfloat* params) nogil
+ctypedef void (__stdcall *GLGETTEXPARAMETERIVPTR)(GLenum target, GLenum pname, GLint* params) nogil
+ctypedef void (__stdcall *GLGETUNIFORMFVPTR)(GLuint program, GLint location, GLfloat* params) nogil
+ctypedef void (__stdcall *GLGETUNIFORMIVPTR)(GLuint program, GLint location, GLint* params) nogil
+ctypedef void (__stdcall *GLGETVERTEXATTRIBFVPTR)(GLuint index, GLenum pname, GLfloat* params) nogil
+ctypedef void (__stdcall *GLGETVERTEXATTRIBIVPTR)(GLuint index, GLenum pname, GLint* params) nogil
+ctypedef void (__stdcall *GLHINTPTR)(GLenum target, GLenum mode) nogil
+ctypedef void (__stdcall *GLLINEWIDTHPTR)(GLfloat width) nogil
+ctypedef void (__stdcall *GLLINKPROGRAMPTR)(GLuint) nogil
+ctypedef void (__stdcall *GLPIXELSTOREIPTR)(GLenum, GLint) nogil
+ctypedef void (__stdcall *GLPOLYGONOFFSETPTR)(GLfloat factor, GLfloat units) nogil
+ctypedef void (__stdcall *GLREADPIXELSPTR)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*) nogil
+ctypedef void (__stdcall *GLRENDERBUFFERSTORAGEPTR)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) nogil
+ctypedef void (__stdcall *GLSAMPLECOVERAGEPTR)(GLclampf value, GLboolean invert) nogil
+ctypedef void (__stdcall *GLSCISSORPTR)(GLint, GLint, GLsizei, GLsizei) nogil
+ctypedef void (__stdcall *GLSHADERBINARYPTR)(GLsizei, const GLuint *, GLenum, const void *, GLsizei) nogil
+ctypedef void (__stdcall *GLSHADERSOURCEPTR)(GLuint, GLsizei, const GLchar* const*, const GLint *) nogil
+ctypedef void (__stdcall *GLSTENCILFUNCPTR)(GLenum func, GLint ref, GLuint mask) nogil
+ctypedef void (__stdcall *GLSTENCILFUNCSEPARATEPTR)(GLenum face, GLenum func, GLint ref, GLuint mask) nogil
+ctypedef void (__stdcall *GLSTENCILMASKPTR)(GLuint mask) nogil
+ctypedef void (__stdcall *GLSTENCILMASKSEPARATEPTR)(GLenum face, GLuint mask) nogil
+ctypedef void (__stdcall *GLSTENCILOPPTR)(GLenum fail, GLenum zfail, GLenum zpass) nogil
+ctypedef void (__stdcall *GLSTENCILOPSEPARATEPTR)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) nogil
+ctypedef void (__stdcall *GLTEXIMAGE2DPTR)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *) nogil
+ctypedef void (__stdcall *GLTEXPARAMETERFPTR)(GLenum target, GLenum pname, GLfloat param) nogil
+ctypedef void (__stdcall *GLTEXPARAMETERIPTR)(GLenum, GLenum, GLint) nogil
+ctypedef void (__stdcall *GLTEXSUBIMAGE2DPTR)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) nogil
+ctypedef void (__stdcall *GLUNIFORM1FPTR)(GLint location, GLfloat x) nogil
+ctypedef void (__stdcall *GLUNIFORM1FVPTR)(GLint location, GLsizei count, const GLfloat* v) nogil
+ctypedef void (__stdcall *GLUNIFORM1IPTR)(GLint, GLint) nogil
+ctypedef void (__stdcall *GLUNIFORM1IVPTR)(GLint location, GLsizei count, const GLint* v) nogil
+ctypedef void (__stdcall *GLUNIFORM2FPTR)(GLint location, GLfloat x, GLfloat y) nogil
+ctypedef void (__stdcall *GLUNIFORM2FVPTR)(GLint location, GLsizei count, const GLfloat* v) nogil
+ctypedef void (__stdcall *GLUNIFORM2IPTR)(GLint location, GLint x, GLint y) nogil
+ctypedef void (__stdcall *GLUNIFORM2IVPTR)(GLint location, GLsizei count, const GLint* v) nogil
+ctypedef void (__stdcall *GLUNIFORM3FPTR)(GLint location, GLfloat x, GLfloat y, GLfloat z) nogil
+ctypedef void (__stdcall *GLUNIFORM3FVPTR)(GLint location, GLsizei count, const GLfloat* v) nogil
+ctypedef void (__stdcall *GLUNIFORM3IPTR)(GLint location, GLint x, GLint y, GLint z) nogil
+ctypedef void (__stdcall *GLUNIFORM3IVPTR)(GLint location, GLsizei count, const GLint* v) nogil
+ctypedef void (__stdcall *GLUNIFORM4FPTR)(GLint, GLfloat, GLfloat, GLfloat, GLfloat) nogil
+ctypedef void (__stdcall *GLUNIFORM4FVPTR)(GLint location, GLsizei count, const GLfloat* v) nogil
+ctypedef void (__stdcall *GLUNIFORM4IPTR)(GLint location, GLint x, GLint y, GLint z, GLint w) nogil
+ctypedef void (__stdcall *GLUNIFORM4IVPTR)(GLint location, GLsizei count, const GLint* v) nogil
+ctypedef void (__stdcall *GLUNIFORMMATRIX4FVPTR)(GLint, GLsizei, GLboolean, const GLfloat *) nogil
+ctypedef void (__stdcall *GLUSEPROGRAMPTR)(GLuint) nogil
+ctypedef void (__stdcall *GLVALIDATEPROGRAMPTR)(GLuint program) nogil
+ctypedef void (__stdcall *GLVERTEXATTRIB1FPTR)(GLuint indx, GLfloat x) nogil
+ctypedef void (__stdcall *GLVERTEXATTRIB2FPTR)(GLuint indx, GLfloat x, GLfloat y) nogil
+ctypedef void (__stdcall *GLVERTEXATTRIB3FPTR)(GLuint indx, GLfloat x, GLfloat y, GLfloat z) nogil
+ctypedef void (__stdcall *GLVERTEXATTRIB4FPTR)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) nogil
+ctypedef void (__stdcall *GLVERTEXATTRIBPOINTERPTR)(GLuint, GLint, GLenum, GLboolean, GLsizei, const void *) nogil
+ctypedef void (__stdcall *GLVIEWPORTPTR)(GLint, GLint, GLsizei, GLsizei) nogil
+
+ctypedef struct GLES2_Context:
+    const GLubyte* (__stdcall *glGetString)(GLenum) nogil
+    GLboolean (__stdcall *glIsBuffer)(GLuint buffer) nogil
+    GLboolean (__stdcall *glIsEnabled)(GLenum cap) nogil
+    GLboolean (__stdcall *glIsFramebuffer)(GLuint framebuffer) nogil
+    GLboolean (__stdcall *glIsProgram)(GLuint program) nogil
+    GLboolean (__stdcall *glIsRenderbuffer)(GLuint renderbuffer) nogil
+    GLboolean (__stdcall *glIsShader)(GLuint shader) nogil
+    GLboolean (__stdcall *glIsTexture)(GLuint texture) nogil
+    GLenum (__stdcall *glCheckFramebufferStatus)(GLenum) nogil
+    GLenum (__stdcall *glGetError)() nogil
+    GLint (__stdcall *glGetAttribLocation)(GLuint, const GLchar *) nogil
+    GLint (__stdcall *glGetUniformLocation)(GLuint, const char *) nogil
+    GLuint (__stdcall *glCreateProgram)() nogil
+    GLuint (__stdcall *glCreateShader)(GLenum) nogil
+    void (__stdcall *glActiveTexture)(GLenum) nogil
+    void (__stdcall *glAttachShader)(GLuint, GLuint) nogil
+    void (__stdcall *glBindAttribLocation)(GLuint, GLuint, const char *) nogil
+    void (__stdcall *glBindBuffer)(GLenum, GLuint) nogil
+    void (__stdcall *glBindFramebuffer)(GLenum, GLuint) nogil
+    void (__stdcall *glBindRenderbuffer)(GLenum target, GLuint renderbuffer) nogil
+    void (__stdcall *glBindTexture)(GLenum, GLuint) nogil
+    void (__stdcall *glBlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) nogil
+    void (__stdcall *glBlendEquation)( GLenum mode ) nogil
+    void (__stdcall *glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha) nogil
+    void (__stdcall *glBlendFunc)(GLenum sfactor, GLenum dfactor) nogil
+    void (__stdcall *glBlendFuncSeparate)(GLenum, GLenum, GLenum, GLenum) nogil
+    void (__stdcall *glBufferData)(GLenum, GLsizeiptr, const GLvoid *, GLenum) nogil
+    void (__stdcall *glBufferSubData)(GLenum, GLintptr, GLsizeiptr, const GLvoid *) nogil
+    void (__stdcall *glClear)(GLbitfield) nogil
+    void (__stdcall *glClearColor)(GLclampf, GLclampf, GLclampf, GLclampf) nogil
+    void (__stdcall *glClearStencil)(GLint s) nogil
+    void (__stdcall *glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) nogil
+    void (__stdcall *glCompileShader)(GLuint) nogil
+    void (__stdcall *glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) nogil
+    void (__stdcall *glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) nogil
+    void (__stdcall *glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) nogil
+    void (__stdcall *glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) nogil
+    void (__stdcall *glCullFace)(GLenum mode) nogil
+    void (__stdcall *glDeleteBuffers)(GLsizei n, const GLuint* buffers) nogil
+    void (__stdcall *glDeleteFramebuffers)(GLsizei, const GLuint *) nogil
+    void (__stdcall *glDeleteProgram)(GLuint) nogil
+    void (__stdcall *glDeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers) nogil
+    void (__stdcall *glDeleteShader)(GLuint) nogil
+    void (__stdcall *glDeleteTextures)(GLsizei, const GLuint *) nogil
+    void (__stdcall *glDepthFunc)(GLenum func) nogil
+    void (__stdcall *glDepthMask)(GLboolean flag) nogil
+    void (__stdcall *glDetachShader)(GLuint program, GLuint shader) nogil
+    void (__stdcall *glDisable)(GLenum) nogil
+    void (__stdcall *glDisableVertexAttribArray)(GLuint) nogil
+    void (__stdcall *glDrawArrays)(GLenum, GLint, GLsizei) nogil
+    void (__stdcall *glDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) nogil
+    void (__stdcall *glEnable)(GLenum) nogil
+    void (__stdcall *glEnableVertexAttribArray)(GLuint) nogil
+    void (__stdcall *glFinish)() nogil
+    void (__stdcall *glFlush)() nogil
+    void (__stdcall *glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) nogil
+    void (__stdcall *glFramebufferTexture2D)(GLenum, GLenum, GLenum, GLuint, GLint) nogil
+    void (__stdcall *glFrontFace)(GLenum mode) nogil
+    void (__stdcall *glGenBuffers)(GLsizei, GLuint *) nogil
+    void (__stdcall *glGenerateMipmap)(GLenum target) nogil
+    void (__stdcall *glGenFramebuffers)(GLsizei, GLuint *) nogil
+    void (__stdcall *glGenRenderbuffers)(GLsizei n, GLuint* renderbuffers) nogil
+    void (__stdcall *glGenTextures)(GLsizei, GLuint *) nogil
+    void (__stdcall *glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) nogil
+    void (__stdcall *glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) nogil
+    void (__stdcall *glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) nogil
+    void (__stdcall *glGetBooleanv)(GLenum, GLboolean *) nogil
+    void (__stdcall *glGetBufferParameteriv)(GLenum target, GLenum pname, GLint* params) nogil
+    void (__stdcall *glGetFloatv)(GLenum pname, GLfloat* params) nogil
+    void (__stdcall *glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params) nogil
+    void (__stdcall *glGetIntegerv)(GLenum, GLint *) nogil
+    void (__stdcall *glGetProgramInfoLog)(GLuint, GLsizei, GLsizei*, GLchar*) nogil
+    void (__stdcall *glGetProgramiv)(GLuint, GLenum, GLint *) nogil
+    void (__stdcall *glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params) nogil
+    void (__stdcall *glGetShaderInfoLog)(GLuint, GLsizei, GLsizei *, char *) nogil
+    void (__stdcall *glGetShaderiv)(GLuint, GLenum, GLint *) nogil
+    void (__stdcall *glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) nogil
+    void (__stdcall *glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params) nogil
+    void (__stdcall *glGetTexParameteriv)(GLenum target, GLenum pname, GLint* params) nogil
+    void (__stdcall *glGetUniformfv)(GLuint program, GLint location, GLfloat* params) nogil
+    void (__stdcall *glGetUniformiv)(GLuint program, GLint location, GLint* params) nogil
+    void (__stdcall *glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params) nogil
+    void (__stdcall *glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* params) nogil
+    void (__stdcall *glHint)(GLenum target, GLenum mode) nogil
+    void (__stdcall *glLineWidth)(GLfloat width) nogil
+    void (__stdcall *glLinkProgram)(GLuint) nogil
+    void (__stdcall *glPixelStorei)(GLenum, GLint) nogil
+    void (__stdcall *glPolygonOffset)(GLfloat factor, GLfloat units) nogil
+    void (__stdcall *glReadPixels)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*) nogil
+    void (__stdcall *glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) nogil
+    void (__stdcall *glSampleCoverage)(GLclampf value, GLboolean invert) nogil
+    void (__stdcall *glScissor)(GLint, GLint, GLsizei, GLsizei) nogil
+    void (__stdcall *glShaderBinary)(GLsizei, const GLuint *, GLenum, const void *, GLsizei) nogil
+    void (__stdcall *glShaderSource)(GLuint, GLsizei, const GLchar* const*, const GLint *) nogil
+    void (__stdcall *glStencilFunc)(GLenum func, GLint ref, GLuint mask) nogil
+    void (__stdcall *glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask) nogil
+    void (__stdcall *glStencilMask)(GLuint mask) nogil
+    void (__stdcall *glStencilMaskSeparate)(GLenum face, GLuint mask) nogil
+    void (__stdcall *glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass) nogil
+    void (__stdcall *glStencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) nogil
+    void (__stdcall *glTexImage2D)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *) nogil
+    void (__stdcall *glTexParameterf)(GLenum target, GLenum pname, GLfloat param) nogil
+    void (__stdcall *glTexParameteri)(GLenum, GLenum, GLint) nogil
+    void (__stdcall *glTexSubImage2D)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) nogil
+    void (__stdcall *glUniform1f)(GLint location, GLfloat x) nogil
+    void (__stdcall *glUniform1fv)(GLint location, GLsizei count, const GLfloat* v) nogil
+    void (__stdcall *glUniform1i)(GLint, GLint) nogil
+    void (__stdcall *glUniform1iv)(GLint location, GLsizei count, const GLint* v) nogil
+    void (__stdcall *glUniform2f)(GLint location, GLfloat x, GLfloat y) nogil
+    void (__stdcall *glUniform2fv)(GLint location, GLsizei count, const GLfloat* v) nogil
+    void (__stdcall *glUniform2i)(GLint location, GLint x, GLint y) nogil
+    void (__stdcall *glUniform2iv)(GLint location, GLsizei count, const GLint* v) nogil
+    void (__stdcall *glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z) nogil
+    void (__stdcall *glUniform3fv)(GLint location, GLsizei count, const GLfloat* v) nogil
+    void (__stdcall *glUniform3i)(GLint location, GLint x, GLint y, GLint z) nogil
+    void (__stdcall *glUniform3iv)(GLint location, GLsizei count, const GLint* v) nogil
+    void (__stdcall *glUniform4f)(GLint, GLfloat, GLfloat, GLfloat, GLfloat) nogil
+    void (__stdcall *glUniform4fv)(GLint location, GLsizei count, const GLfloat* v) nogil
+    void (__stdcall *glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w) nogil
+    void (__stdcall *glUniform4iv)(GLint location, GLsizei count, const GLint* v) nogil
+    void (__stdcall *glUniformMatrix4fv)(GLint, GLsizei, GLboolean, const GLfloat *) nogil
+    void (__stdcall *glUseProgram)(GLuint) nogil
+    void (__stdcall *glValidateProgram)(GLuint program) nogil
+    void (__stdcall *glVertexAttrib1f)(GLuint indx, GLfloat x) nogil
+    void (__stdcall *glVertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y) nogil
+    void (__stdcall *glVertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z) nogil
+    void (__stdcall *glVertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) nogil
+    void (__stdcall *glVertexAttribPointer)(GLuint, GLint, GLenum, GLboolean, GLsizei, const void *) nogil
+    void (__stdcall *glViewport)(GLint, GLint, GLsizei, GLsizei) nogil
+
+cdef GLES2_Context *cgl
+cdef int kivy_opengl_es2
+cdef unsigned long initialized_tid
+cdef public int verify_gl_main_thread
+cpdef cgl_init(allowed=*, ignored=*)
+cdef GLES2_Context *cgl_get_context()
+cdef void cgl_set_context(GLES2_Context* ctx)
+cpdef cgl_get_backend_name(allowed=*, ignored=*)
+cpdef cgl_get_initialized_backend_name()
diff --git a/kivy/graphics/cgl_backend/__init__.py b/kivy/graphics/cgl_backend/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/kivy/graphics/cgl_backend/__pycache__/__init__.cpython-310.pyc b/kivy/graphics/cgl_backend/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..59c3992
Binary files /dev/null and b/kivy/graphics/cgl_backend/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/graphics/cgl_backend/cgl_debug.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/cgl_backend/cgl_debug.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..bc9cd4f
Binary files /dev/null and b/kivy/graphics/cgl_backend/cgl_debug.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/cgl_backend/cgl_gl.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/cgl_backend/cgl_gl.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..ad5b862
Binary files /dev/null and b/kivy/graphics/cgl_backend/cgl_gl.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/cgl_backend/cgl_glew.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/cgl_backend/cgl_glew.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..0288264
Binary files /dev/null and b/kivy/graphics/cgl_backend/cgl_glew.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/cgl_backend/cgl_mock.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/cgl_backend/cgl_mock.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..7a0c978
Binary files /dev/null and b/kivy/graphics/cgl_backend/cgl_mock.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/cgl_backend/cgl_sdl2.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/cgl_backend/cgl_sdl2.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..9e452ec
Binary files /dev/null and b/kivy/graphics/cgl_backend/cgl_sdl2.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/common.pxi b/kivy/graphics/common.pxi
new file mode 100644
index 0000000..f4d098c
--- /dev/null
+++ b/kivy/graphics/common.pxi
@@ -0,0 +1,32 @@
+#
+# Common definition
+#
+
+DEF PI2 = 1.5707963267948966
+DEF PI = 3.1415926535897931
+
+cdef extern from *:
+    ctypedef char* const_char_ptr "const char*"
+
+cdef double pi = PI
+cdef extern from "math.h":
+    double cos(double) nogil
+    double acos(double) nogil
+    double sin(double) nogil
+    double sqrt(double) nogil
+    double pow(double x, double y) nogil
+    double atan2(double y, double x) nogil
+    double tan(double) nogil
+    double fabs(double) nogil
+
+cdef extern from "stdlib.h":
+    ctypedef unsigned long size_t
+    void free(void *ptr) nogil
+    void *realloc(void *ptr, size_t size) nogil
+    void *malloc(size_t size) nogil
+    void *calloc(size_t nmemb, size_t size) nogil
+
+cdef extern from "string.h":
+    void *memcpy(void *dest, void *src, size_t n) nogil
+    void *memset(void *dest, int c, size_t len)
+
diff --git a/kivy/graphics/compiler.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/compiler.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..c698fd9
Binary files /dev/null and b/kivy/graphics/compiler.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/compiler.pxd b/kivy/graphics/compiler.pxd
new file mode 100644
index 0000000..112c76b
--- /dev/null
+++ b/kivy/graphics/compiler.pxd
@@ -0,0 +1,6 @@
+cdef class GraphicsCompiler
+
+from .instructions cimport InstructionGroup
+
+cdef class GraphicsCompiler:
+    cdef InstructionGroup compile(self, InstructionGroup group)
diff --git a/kivy/graphics/context.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/context.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..d8da157
Binary files /dev/null and b/kivy/graphics/context.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/context.pxd b/kivy/graphics/context.pxd
new file mode 100644
index 0000000..999ac45
--- /dev/null
+++ b/kivy/graphics/context.pxd
@@ -0,0 +1,36 @@
+from kivy.graphics.instructions cimport Instruction, Canvas
+from kivy.graphics.texture cimport Texture
+from kivy.graphics.vbo cimport VBO, VertexBatch
+from kivy.graphics.shader cimport Shader
+from kivy.graphics.fbo cimport Fbo
+
+cdef class Context:
+    cdef list observers
+    cdef list observers_before
+    cdef list l_texture
+    cdef list l_canvas
+    cdef list l_fbo
+
+    cdef object lr_texture
+    cdef list lr_canvas
+    cdef object lr_vbo
+    cdef object lr_fbo_rb
+    cdef object lr_fbo_fb
+    cdef object lr_shadersource
+    cdef list lr_shader
+
+    cdef void register_texture(self, Texture texture)
+    cdef void register_canvas(self, Canvas canvas)
+    cdef void register_fbo(self, Fbo fbo)
+
+    cdef void dealloc_texture(self, Texture texture)
+    cdef void dealloc_vbo(self, VBO vbo)
+    cdef void dealloc_vertexbatch(self, VertexBatch vbo)
+    cdef void dealloc_shader(self, Shader shader)
+    cdef void dealloc_shader_source(self, int shader)
+    cdef void dealloc_fbo(self, Fbo fbo)
+
+    cdef object trigger_gl_dealloc
+    cpdef void flush(self)
+
+cpdef Context get_context()
diff --git a/kivy/graphics/context_instructions.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/context_instructions.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..60e252c
Binary files /dev/null and b/kivy/graphics/context_instructions.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/context_instructions.pxd b/kivy/graphics/context_instructions.pxd
new file mode 100644
index 0000000..64f3b1d
--- /dev/null
+++ b/kivy/graphics/context_instructions.pxd
@@ -0,0 +1,77 @@
+cdef class LineWidth
+cdef class Color
+cdef class BindTexture
+
+from .transformation cimport Matrix
+from .instructions cimport ContextInstruction
+from .texture cimport Texture
+
+cdef class PushState(ContextInstruction):
+    pass
+
+cdef class ChangeState(ContextInstruction):
+    pass
+
+cdef class PopState(ContextInstruction):
+    pass
+
+cdef class LineWidth(ContextInstruction):
+    cdef int apply(self) except -1
+
+cdef class Color(ContextInstruction):
+    cdef int apply(self) except -1
+
+cdef class BindTexture(ContextInstruction):
+    cdef int _index
+    cdef object _source
+    cdef Texture _texture
+    cdef int apply(self) except -1
+
+
+cdef class LoadIdentity(ContextInstruction):
+    pass
+
+cdef class PushMatrix(ContextInstruction):
+    cdef int apply(self) except -1
+
+cdef class PopMatrix(ContextInstruction):
+    cdef int apply(self) except -1
+
+cdef class ApplyContextMatrix(ContextInstruction):
+    cdef object _target_stack
+    cdef object _source_stack
+    cdef int apply(self) except -1
+
+cdef class UpdateNormalMatrix(ContextInstruction):
+    cdef int apply(self) except -1
+
+cdef class MatrixInstruction(ContextInstruction):
+    cdef object _stack
+    cdef Matrix _matrix
+    cdef int apply(self) except -1
+
+cdef class Transform(MatrixInstruction):
+    cpdef transform(self, Matrix trans)
+    cpdef translate(self, float tx, float ty, float tz)
+    cpdef rotate(self, float angle, float ax, float ay, float az)
+    cpdef scale(self, float s)
+    cpdef identity(self)
+
+cdef class Rotate(Transform):
+    cdef float _angle
+    cdef tuple _axis
+    cdef tuple _origin
+    cdef int apply(self) except -1
+    cdef void compute(self)
+
+cdef class Scale(Transform):
+    cdef tuple _origin
+    cdef double _x, _y, _z
+    cdef int apply(self) except -1
+    cdef set_scale(self, double x, double y, double z)
+
+cdef class Translate(Transform):
+    cdef double _x, _y, _z
+    cdef int apply(self) except -1
+    cdef set_translate(self, double x, double y, double z)
+
diff --git a/kivy/graphics/fbo.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/fbo.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..a1d9129
Binary files /dev/null and b/kivy/graphics/fbo.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/fbo.pxd b/kivy/graphics/fbo.pxd
new file mode 100644
index 0000000..43393d3
--- /dev/null
+++ b/kivy/graphics/fbo.pxd
@@ -0,0 +1,31 @@
+from kivy.graphics.cgl cimport GLuint, GLint
+from kivy.graphics.instructions cimport RenderContext, Canvas
+from kivy.graphics.texture cimport Texture
+
+cdef class Fbo(RenderContext):
+    cdef int _width
+    cdef int _height
+    cdef int _depthbuffer_attached
+    cdef int _stencilbuffer_attached
+    cdef int _push_viewport
+    cdef float _clear_color[4]
+    cdef GLuint buffer_id
+    cdef GLuint depthbuffer_id
+    cdef GLuint stencilbuffer_id
+    cdef GLint _viewport[4]
+    cdef Texture _texture
+    cdef int _is_bound
+    cdef object _stencil_state
+    cdef list observers
+
+    cpdef clear_buffer(self)
+    cpdef bind(self)
+    cpdef release(self)
+    cpdef get_pixel_color(self, int wx, int wy)
+
+    cdef void create_fbo(self)
+    cdef void delete_fbo(self)
+    cdef int apply(self) except -1
+    cdef void raise_exception(self, str message, int status=?)
+    cdef str resolve_status(self, int status)
+    cdef void reload(self) except *
diff --git a/kivy/graphics/gl_debug_logger.pxi b/kivy/graphics/gl_debug_logger.pxi
new file mode 100644
index 0000000..5da21dd
--- /dev/null
+++ b/kivy/graphics/gl_debug_logger.pxi
@@ -0,0 +1,13 @@
+from kivy.logger import Logger
+include "../include/config.pxi"
+
+from kivy.graphics.cgl cimport cgl
+import os
+cdef int env_debug_gl = "DEBUG_GL" in os.environ
+
+cdef inline void log_gl_error(str note):
+    if env_debug_gl:
+        ret = cgl.glGetError()
+        if ret:
+            Logger.error("OpenGL Error: {note} {ret1} / {ret2}".format(
+                note=note, ret1=ret, ret2=hex(ret)))
diff --git a/kivy/graphics/gl_instructions.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/gl_instructions.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..4338936
Binary files /dev/null and b/kivy/graphics/gl_instructions.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/img_tools.pxi b/kivy/graphics/img_tools.pxi
new file mode 100644
index 0000000..7784179
--- /dev/null
+++ b/kivy/graphics/img_tools.pxi
@@ -0,0 +1,114 @@
+from kivy.graphics.opengl_utils cimport (gl_has_texture_native_format,
+    gl_has_texture_conversion)
+cimport cython
+from cython cimport view as cyview
+from cpython.array cimport array, clone
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef inline convert_to_gl_format(data, fmt, width, height):
+    ''' Takes data as a bytes object or an instance that implements the python
+    buffer interface. If the data format is supported by opengl, the data
+    is returned unchanged. Otherwise, the data is converted to a supported
+    format, when possible, and returned as a python array object.
+
+    Note that conversion is currently only supported for bytes data.
+    '''
+    cdef array ret_array
+    cdef char *src_buffer
+    cdef char *dst_buffer
+    cdef char [::1] view
+    cdef int datasize
+    cdef str ret_format
+    cdef int i, k
+    cdef char c, c2
+    cdef int pitch, rowlen
+    cdef int pitchalign = 0
+
+    # if native support of this format is available, use it
+    if gl_has_texture_native_format(fmt):
+        return data, fmt
+
+    # no native support, can we at least convert it ?
+    if not gl_has_texture_conversion(fmt):
+        raise Exception('Unimplemented texture conversion for {}'.format(fmt))
+
+    # do appropriate conversion, since we accepted it
+    if isinstance(data, bytes):
+        datasize = <int>len(data)
+        ret_array = clone(array('b'), datasize, False)
+        src_buffer = <char *>data
+    else:
+        view = data
+        datasize = view.nbytes
+        ret_array = clone(array('b'), datasize, False)
+        src_buffer = &view[0]
+    dst_buffer = ret_array.data.as_chars
+
+    # BGR -> RGB
+    if fmt == 'bgr':
+        ret_format = 'rgb'
+        memcpy(dst_buffer, src_buffer, datasize)
+
+        i = 0
+        rowlen = width * 3
+        pitch = (rowlen + 3) & ~3
+        if rowlen * height < datasize:
+            # FIXME: warn/fail if pitch * height != datasize:
+            pitchalign = pitch - rowlen
+            rowlen -= 1 # to match 0-based k below
+
+        # note, this is the fastest copying method. copying element by element
+        # from a memoryview is slower then copying the whole buffer and then
+        # properly modifying the elements
+        with nogil:
+            while i < datasize:
+                c = dst_buffer[i]
+                k = i + 2
+                dst_buffer[i] = dst_buffer[k]
+                dst_buffer[k] = c
+                if pitchalign and k % rowlen == 0:
+                    i += pitchalign
+                i += 3
+
+    # BGRA -> RGBA
+    elif fmt == 'bgra':
+        ret_format = 'rgba'
+        memcpy(dst_buffer, src_buffer, datasize)
+        with nogil:
+            for i in range(0, datasize, 4):
+                c = dst_buffer[i]
+                dst_buffer[i] = dst_buffer[i + 2]
+                dst_buffer[i + 2] = c
+
+    # ARGB -> RGBA
+    elif fmt == 'argb':
+        ret_format = 'rgba'
+        memcpy(dst_buffer, &src_buffer[1], datasize-1)
+        c2 = src_buffer[0]
+        with nogil:
+            for i in range(0, datasize, 4):
+                c = dst_buffer[i+3]
+                dst_buffer[i+3] = c2
+                c2 = c
+
+    # ABGR -> RGBA
+    elif fmt == 'abgr':
+        ret_format = 'rgba'
+        memcpy(dst_buffer, &src_buffer[1], datasize-1)
+        c2 = src_buffer[0]
+        with nogil:
+            for i in range(0, datasize, 4):
+                c = dst_buffer[i+3]
+                dst_buffer[i+3] = c2
+                c2 = c
+
+                c = dst_buffer[i]
+                dst_buffer[i] = dst_buffer[i + 2]
+                dst_buffer[i + 2] = c
+
+    else:
+        assert False, 'Non implemented texture conversion {}'.format(fmt)
+
+    return ret_array, ret_format
diff --git a/kivy/graphics/instructions.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/instructions.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..4361863
Binary files /dev/null and b/kivy/graphics/instructions.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/instructions.pxd b/kivy/graphics/instructions.pxd
new file mode 100644
index 0000000..f24f233
--- /dev/null
+++ b/kivy/graphics/instructions.pxd
@@ -0,0 +1,129 @@
+include "../include/config.pxi"
+
+cdef class Instruction
+cdef class InstructionGroup
+cdef class ContextInstruction
+cdef class VertexInstruction
+cdef class CanvasBase
+cdef class Canvas
+cdef class RenderContext
+
+from .vbo cimport *
+from .compiler cimport *
+from .shader cimport *
+from .texture cimport Texture
+from kivy._event cimport ObjectWithUid
+
+cdef void reset_gl_context()
+
+cdef class Instruction
+cdef class InstructionGroup(Instruction)
+
+cdef class Instruction(ObjectWithUid):
+    cdef int flags
+    cdef public str group
+    cdef InstructionGroup parent
+    cdef object __weakref__
+    cdef object __proxy_ref
+
+    cdef int apply(self) except -1
+    IF DEBUG:
+        cpdef flag_update(self, int do_parent=?, list _instrs=?)
+    ELSE:
+        cpdef flag_update(self, int do_parent=?)
+    cpdef flag_data_update(self)
+    cdef void flag_update_done(self)
+    cdef void set_parent(self, Instruction parent)
+    cdef void reload(self) except *
+
+    cdef void radd(self, InstructionGroup ig)
+    cdef void rinsert(self, InstructionGroup ig, int index)
+    cdef void rremove(self, InstructionGroup ig)
+
+cdef class InstructionGroup(Instruction):
+    cdef public list children
+    cdef InstructionGroup compiled_children
+    cdef GraphicsCompiler compiler
+    cdef void build(self)
+    cdef void reload(self) except *
+    cpdef add(self, Instruction c)
+    cpdef insert(self, int index, Instruction c)
+    cpdef remove(self, Instruction c)
+    cpdef clear(self)
+    cpdef remove_group(self, str groupname)
+    cpdef get_group(self, str groupname)
+
+cdef class ContextInstruction(Instruction):
+    cdef dict context_state
+    cdef list context_push
+    cdef list context_pop
+
+    cdef RenderContext get_context(self)
+    cdef int set_state(self, str name, value) except -1
+    cdef int push_state(self, str name) except -1
+    cdef int pop_state(self, str name) except -1
+
+
+from .context_instructions cimport BindTexture
+
+cdef class VertexInstruction(Instruction):
+    cdef BindTexture texture_binding
+    cdef VertexBatch batch
+    cdef float _tex_coords[8]
+
+    cdef void radd(self, InstructionGroup ig)
+    cdef void rinsert(self, InstructionGroup ig, int index)
+    cdef void rremove(self, InstructionGroup ig)
+
+    cdef void build(self)
+
+cdef class Callback(Instruction):
+    cdef Shader _shader
+    cdef object func
+    cdef int _reset_context
+    cdef int apply(self) except -1
+    cdef int enter(self) except -1
+
+
+
+cdef CanvasBase getActiveCanvas()
+
+cdef class CanvasBase(InstructionGroup):
+    pass
+
+cdef class Canvas(CanvasBase):
+    cdef float _opacity
+    cdef CanvasBase _before
+    cdef CanvasBase _after
+    cdef void reload(self) except *
+    cpdef clear(self)
+    cpdef add(self, Instruction c)
+    cpdef remove(self, Instruction c)
+    cpdef draw(self)
+    cdef int apply(self) except -1
+
+
+cdef class RenderContext(Canvas):
+    cdef Shader _shader
+    cdef dict state_stacks
+    cdef Texture default_texture
+    cdef dict bind_texture
+    cdef int _use_parent_projection
+    cdef int _use_parent_modelview
+    cdef int _use_parent_frag_modelview
+
+    cdef void set_texture(self, int index, Texture texture)
+    cdef void set_state(self, str name, value, int apply_now=?)
+    cdef get_state(self, str name)
+    cdef int set_states(self, dict states) except -1
+    cdef int push_state(self, str name) except -1
+    cdef int push_states(self, list names) except -1
+    cdef int pop_state(self, str name) except -1
+    cdef int pop_states(self, list names) except -1
+    cdef int enter(self) except -1
+    cdef int leave(self) except -1
+    cdef int apply(self) except -1
+    cpdef draw(self)
+    cdef void reload(self) except *
+
+cdef RenderContext getActiveContext()
diff --git a/kivy/graphics/memory.pxi b/kivy/graphics/memory.pxi
new file mode 100644
index 0000000..ac3dd2d
--- /dev/null
+++ b/kivy/graphics/memory.pxi
@@ -0,0 +1,74 @@
+from cpython.array cimport array, clone
+
+
+'''
+These functions below, take a data element; if the data implements the
+buffer interface, the data is returned unchanged, otherwise, a python
+array is created from the data and returned.
+
+in both cases, the second parameter is initialized with a pointer to the
+starting address of the returned buffer
+
+The return value is a tuple, of (original data, array), where in the first
+case, array is None.
+
+The method used below (a untyped python array + array.data.as_floats pointer)
+results in the fastest list to array creation and usage. Even malloc isn't
+faster. Note, using memoryview (which we avoided for this case) is relatively
+slow in cython.
+
+When the user passes in a memoryview type, we have no choice but to use the
+memoryview passed in, though.
+'''
+cdef inline _ensure_float_view(data, float **f):
+    cdef array arr
+    cdef list src
+    cdef int i
+    cdef float [::1] memview
+    # do if/else instead of straight try/except because its faster for list
+    if not isinstance(data, (tuple, list)):
+        try:
+            memview = data
+            f[0] = &memview[0]
+            return data, None
+        except Exception as e:
+            import traceback; traceback.print_exc() 
+            src = list(data)
+            arr = clone(array('f'), len(src), False)
+            f[0] = arr.data.as_floats
+            for i in range(len(src)):
+                f[0][i] = src[i]
+    else:
+        src = list(data)
+        arr = clone(array('f'), len(src), False)
+        f[0] = arr.data.as_floats
+        for i in range(len(src)):
+            f[0][i] = src[i]
+    return src, arr
+
+
+cdef inline _ensure_ushort_view(data, unsigned short **f):
+    cdef array arr
+    cdef list src
+    cdef int i
+    cdef unsigned short [::1] memview
+    # do if/else instead of straight try/except because its faster for list
+    if not isinstance(data, (tuple, list)):
+        try:
+            memview = data
+            f[0] = &memview[0]
+            return data, None
+        except:
+            src = list(data)
+            arr = clone(array('H'), len(src), False)
+            f[0] = arr.data.as_ushorts
+            for i in range(len(src)):
+                f[0][i] = src[i]
+    else:
+        src = list(data)
+        arr = clone(array('H'), len(src), False)
+        f[0] = arr.data.as_ushorts
+        for i in range(len(src)):
+            f[0][i] = src[i]
+    return src, arr
+
diff --git a/kivy/graphics/opcodes.pxi b/kivy/graphics/opcodes.pxi
new file mode 100644
index 0000000..df74f08
--- /dev/null
+++ b/kivy/graphics/opcodes.pxi
@@ -0,0 +1,10 @@
+cdef int GI_NOOP         = 1 << 0
+cdef int GI_IGNORE       = 1 << 1
+cdef int GI_NEEDS_UPDATE = 1 << 2
+cdef int GI_GROUP        = 1 << 3
+cdef int GI_CONTEXT_MOD  = 1 << 4
+cdef int GI_VERTEX_DATA  = 1 << 5
+cdef int GI_COMPILER	 = 1 << 6
+cdef int GI_NO_APPLY_ONCE = 1 << 7
+cdef int GI_NO_REMOVE    = 1 << 8
+
diff --git a/kivy/graphics/opengl.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/opengl.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..9d6d9da
Binary files /dev/null and b/kivy/graphics/opengl.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/opengl_utils.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/opengl_utils.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..0f655b8
Binary files /dev/null and b/kivy/graphics/opengl_utils.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/opengl_utils.pxd b/kivy/graphics/opengl_utils.pxd
new file mode 100644
index 0000000..e95c1ff
--- /dev/null
+++ b/kivy/graphics/opengl_utils.pxd
@@ -0,0 +1,11 @@
+cpdef list gl_get_extensions()
+cpdef int gl_has_extension(name)
+cpdef gl_register_get_size(int constid, int size)
+cpdef int gl_has_capability(int cap)
+cpdef tuple gl_get_texture_formats()
+cpdef int gl_has_texture_native_format(fmt)
+cpdef int gl_has_texture_conversion(fmt)
+cpdef int gl_has_texture_format(fmt)
+cpdef tuple gl_get_version()
+cpdef int gl_get_version_major()
+cpdef int gl_get_version_minor()
diff --git a/kivy/graphics/opengl_utils_def.pxi b/kivy/graphics/opengl_utils_def.pxi
new file mode 100644
index 0000000..3e7b1b2
--- /dev/null
+++ b/kivy/graphics/opengl_utils_def.pxi
@@ -0,0 +1,17 @@
+# c definition
+cdef int c_GLCAP_BGRA = 0x0001
+cdef int c_GLCAP_NPOT = 0x0002
+cdef int c_GLCAP_S3TC = 0x0003
+cdef int c_GLCAP_DXT1 = 0x0004
+cdef int c_GLCAP_PVRTC = 0x0005
+cdef int c_GLCAP_ETC1 = 0x0006
+cdef int c_GLCAP_UNPACK_SUBIMAGE = 0x0007
+
+# for python export
+GLCAP_BGRA = c_GLCAP_NPOT
+GLCAP_NPOT = c_GLCAP_NPOT
+GLCAP_S3TC = c_GLCAP_S3TC
+GLCAP_DXT1 = c_GLCAP_DXT1
+GLCAP_PVRTC = c_GLCAP_PVRTC
+GLCAP_ETC1 = c_GLCAP_ETC1
+GLCAP_UNPACK_SUBIMAGE = c_GLCAP_UNPACK_SUBIMAGE
diff --git a/kivy/graphics/scissor_instructions.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/scissor_instructions.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..bfdb7b0
Binary files /dev/null and b/kivy/graphics/scissor_instructions.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/shader.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/shader.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..b7dbf9e
Binary files /dev/null and b/kivy/graphics/shader.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/shader.pxd b/kivy/graphics/shader.pxd
new file mode 100644
index 0000000..413aafe
--- /dev/null
+++ b/kivy/graphics/shader.pxd
@@ -0,0 +1,42 @@
+from kivy.graphics.cgl cimport GLuint, GLint
+from kivy.graphics.transformation cimport Matrix
+from kivy.graphics.vertex cimport VertexFormat
+
+cdef class ShaderSource:
+    cdef int shader
+    cdef int shadertype
+    cdef set_source(self, char *source)
+    cdef get_shader_log(self, int shader)
+    cdef void process_message(self, str ctype, message)
+    cdef int is_compiled(self)
+
+cdef class Shader:
+    cdef object __weakref__
+
+    cdef int _success
+    cdef VertexFormat _current_vertex_format
+    cdef GLint program
+    cdef ShaderSource vertex_shader
+    cdef ShaderSource fragment_shader
+    cdef object _source
+    cdef object vert_src
+    cdef object frag_src
+    cdef dict uniform_locations
+    cdef dict uniform_values
+
+    cdef void use(self)
+    cdef void stop(self)
+    cdef int set_uniform(self, str name, value) except -1
+    cdef int upload_uniform(self, str name, value) except -1
+    cdef void upload_uniform_matrix(self, int loc, Matrix value)
+    cdef int get_uniform_loc(self, str name) except *
+    cdef int build(self) except -1
+    cdef int build_vertex(self, int link=*) except -1
+    cdef int build_fragment(self, int link=*) except -1
+    cdef int link_program(self) except -1
+    cdef int is_linked(self)
+    cdef ShaderSource compile_shader(self, str source, int shadertype)
+    cdef get_program_log(self, shader)
+    cdef void process_message(self, str ctype, message)
+    cdef void reload(self)
+    cdef void bind_vertex_format(self, VertexFormat vertex_format)
diff --git a/kivy/graphics/stencil_instructions.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/stencil_instructions.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..56a545c
Binary files /dev/null and b/kivy/graphics/stencil_instructions.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/stencil_instructions.pxd b/kivy/graphics/stencil_instructions.pxd
new file mode 100644
index 0000000..549beb2
--- /dev/null
+++ b/kivy/graphics/stencil_instructions.pxd
@@ -0,0 +1,18 @@
+from kivy.graphics.instructions cimport Instruction
+
+cdef get_stencil_state()
+cdef void restore_stencil_state(dict state)
+cdef void reset_stencil_state()
+
+cdef class StencilPush(Instruction):
+    cdef int apply(self) except -1
+
+cdef class StencilPop(Instruction):
+    cdef int apply(self) except -1
+
+cdef class StencilUse(Instruction):
+    cdef int _op
+    cdef int apply(self) except -1
+
+cdef class StencilUnUse(Instruction):
+    cdef int apply(self) except -1
diff --git a/kivy/graphics/svg.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/svg.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..44cf3b5
Binary files /dev/null and b/kivy/graphics/svg.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/svg.pxd b/kivy/graphics/svg.pxd
new file mode 100644
index 0000000..ed99e9b
--- /dev/null
+++ b/kivy/graphics/svg.pxd
@@ -0,0 +1,80 @@
+cdef class Matrix
+cdef class Svg
+
+from cython cimport view
+from kivy.graphics.instructions cimport RenderContext
+from kivy.graphics.texture cimport Texture
+from kivy.graphics.vertex cimport VertexFormat
+from kivy.graphics.vertex_instructions cimport StripMesh
+from cpython cimport array
+from array import array
+
+cdef set COMMANDS
+cdef set UPPERCASE
+cdef object RE_LIST
+cdef object RE_COMMAND
+cdef object RE_FLOAT
+cdef object RE_POLYLINE
+cdef object RE_TRANSFORM
+cdef VertexFormat VERTEX_FORMAT
+ctypedef double matrix_t[6]
+cdef list kv_color_to_int_color(color)
+cdef float parse_float(txt)
+cdef list parse_list(string)
+cdef dict parse_style(string)
+cdef parse_color(c, current_color=?)
+
+cdef class Matrix:
+    cdef matrix_t mat
+    cdef void transform(self, float ox, float oy, float *x, float *y)
+    cpdef Matrix inverse(self)
+
+cdef class Svg(RenderContext):
+    cdef public double width
+    cdef public double height
+    cdef float line_width
+    cdef list paths
+    cdef object transform
+    cdef object fill
+    cdef object tree
+    cdef public object current_color
+    cdef object stroke
+    cdef float opacity
+    cdef float x
+    cdef float y
+    cdef int close_index
+    cdef list path
+    cdef array.array loop
+    cdef int bezier_points
+    cdef int circle_points
+    cdef public object gradients
+    cdef view.array bezier_coefficients
+    cdef float anchor_x
+    cdef float anchor_y
+    cdef double last_cx
+    cdef double last_cy
+    cdef Texture line_texture
+    cdef StripMesh last_mesh
+    cdef bint closed
+    cdef float vbox_x, vbox_y, vbox_width, vbox_height
+    cdef str _source
+
+    cdef void reload(self) except *
+    cdef parse_tree(self, tree)
+    cdef parse_element(self, e)
+    cdef list parse_transform(self, transform_def)
+    cdef parse_path(self, pathdef)
+    cdef void new_path(self)
+    cdef void close_path(self)
+    cdef void set_position(self, double x, double y, int absolute=*)
+    cdef arc_to(self, double rx, double ry, double phi, double large_arc,
+            double sweep, double x, double y)
+    cdef void quadratic_bezier_curve_to(self, float cx, float cy, float x, float y)
+    cdef void curve_to(self, float x1, float y1, float x2, float y2,
+            float x, float y)
+    cdef void end_path(self)
+    cdef void push_mesh(self, float[:] path, fill, Matrix transform, mode)
+    cdef void push_strip_mesh(self, float *vertices, int vindex, int count,
+                              int mode=*)
+    cdef void push_line_mesh(self, float[:] path, fill, Matrix transform, float width)
+    cdef void render(self)
diff --git a/kivy/graphics/tesselator.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/tesselator.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..0f38e88
Binary files /dev/null and b/kivy/graphics/tesselator.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/tesselator.pxd b/kivy/graphics/tesselator.pxd
new file mode 100644
index 0000000..bb0b435
--- /dev/null
+++ b/kivy/graphics/tesselator.pxd
@@ -0,0 +1,9 @@
+cdef class Tesselator:
+    cdef void *tess
+    cdef int element_type
+    cdef int polysize
+    cdef void add_contour_data(self, void *cdata, int count)
+    cdef iterate_vertices(self, int mode)
+    cpdef int tesselate(
+            self, int winding_rule=?,
+            int element_type=?, int polysize=?)
diff --git a/kivy/graphics/texture.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/texture.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..5954d57
Binary files /dev/null and b/kivy/graphics/texture.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/texture.pxd b/kivy/graphics/texture.pxd
new file mode 100644
index 0000000..841321e
--- /dev/null
+++ b/kivy/graphics/texture.pxd
@@ -0,0 +1,49 @@
+from kivy.graphics.cgl cimport GLuint
+
+cdef class Texture:
+    cdef object __weakref__
+    cdef unsigned int flags
+
+    cdef object _source
+    cdef float _tex_coords[8]
+    cdef int _width
+    cdef int _height
+    cdef GLuint _target
+    cdef GLuint _id
+    cdef int _mipmap
+    cdef object _wrap
+    cdef object _min_filter
+    cdef object _mag_filter
+    cdef int _rectangle
+    cdef object _colorfmt
+    cdef object _icolorfmt
+    cdef object _bufferfmt
+    cdef float _uvx
+    cdef float _uvy
+    cdef float _uvw
+    cdef float _uvh
+    cdef int _is_allocated
+    cdef int _nofree
+    cdef list observers
+    cdef object _proxyimage
+    cdef object _callback
+
+    cdef void update_tex_coords(self)
+    cdef void set_min_filter(self, x)
+    cdef void set_mag_filter(self, x)
+    cdef void set_wrap(self, x)
+    cdef void reload(self)
+    cdef void _reload_propagate(self, Texture texture)
+    cdef void allocate(self)
+
+    cpdef flip_vertical(self)
+    cpdef flip_horizontal(self)
+    cpdef get_region(self, x, y, width, height)
+    cpdef bind(self)
+
+cdef class TextureRegion(Texture):
+    cdef int x
+    cdef int y
+    cdef Texture owner
+    cdef void reload(self)
+    cpdef bind(self)
diff --git a/kivy/graphics/transformation.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/transformation.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..cbd809f
Binary files /dev/null and b/kivy/graphics/transformation.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/transformation.pxd b/kivy/graphics/transformation.pxd
new file mode 100644
index 0000000..62705ef
--- /dev/null
+++ b/kivy/graphics/transformation.pxd
@@ -0,0 +1,38 @@
+ctypedef double matrix_t[16]
+
+cdef class Matrix:
+    cdef matrix_t mat
+
+    cpdef Matrix identity(self)
+
+    cpdef Matrix inverse(self)
+
+    cpdef Matrix transpose(self)
+
+    cpdef Matrix multiply(Matrix self, Matrix mb)
+
+    cpdef Matrix scale(Matrix self, double x, double y, double z)
+
+    cpdef Matrix translate(Matrix self, double x, double y, double z)
+
+    cpdef Matrix rotate(Matrix self,
+            double angle, double x, double y, double z)
+
+    cpdef Matrix view_clip(Matrix self, double left, double right,
+            double bottom, double top,
+            double near, double far, int perspective)
+
+    cpdef Matrix perspective(Matrix self, double fovy, double aspect,
+            double zNear, double zFar)
+
+    cpdef look_at(Matrix self, double eyex, double eyey, double eyez,
+            double centerx, double centery, double centerz,
+            double upx, double upy, double upz)
+
+    cpdef Matrix normal_matrix(self)
+
+    cpdef tuple transform_point(Matrix self, double x, double y, double z,
+            t=?)
+
+    cpdef project(Matrix self, double objx, double objy, double objz, Matrix model, Matrix proj,
+            double vx, double vy, double vw, double vh)
diff --git a/kivy/graphics/vbo.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/vbo.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..580435c
Binary files /dev/null and b/kivy/graphics/vbo.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/vbo.pxd b/kivy/graphics/vbo.pxd
new file mode 100644
index 0000000..05ee3ea
--- /dev/null
+++ b/kivy/graphics/vbo.pxd
@@ -0,0 +1,54 @@
+from kivy.graphics.buffer cimport Buffer
+from kivy.graphics.vertex cimport vertex_t, vertex_attr_t, VertexFormat
+from kivy.graphics.cgl cimport GLuint
+
+cdef VertexFormat default_vertex
+
+cdef class VBO:
+    cdef object __weakref__
+
+    cdef GLuint id
+    cdef int usage
+    cdef int target
+    cdef vertex_attr_t *format
+    cdef long format_count
+    cdef long format_size
+    cdef Buffer data
+    cdef short flags
+    cdef long vbo_size
+    cdef VertexFormat vertex_format
+
+    cdef void update_buffer(self)
+    cdef void bind(self)
+    cdef void unbind(self)
+    cdef void add_vertex_data(self, void *v, unsigned short* indices, int count)
+    cdef void update_vertex_data(self, int index, void* v, int count)
+    cdef void remove_vertex_data(self, unsigned short* indices, int count)
+    cdef void reload(self)
+    cdef int have_id(self)
+
+
+cdef class VertexBatch:
+    cdef object __weakref__
+
+    cdef VBO vbo
+    cdef Buffer elements
+    cdef Buffer vbo_index
+    cdef GLuint mode
+    cdef str mode_str
+    cdef GLuint id
+    cdef int usage
+    cdef short flags
+    cdef long elements_size
+
+    cdef void clear_data(self)
+    cdef void set_data(self, void *vertices, int vertices_count,
+                       unsigned short *indices, int indices_count)
+    cdef void append_data(self, void *vertices, int vertices_count,
+                          unsigned short *indices, int indices_count)
+    cdef void draw(self)
+    cdef void set_mode(self, str mode)
+    cdef str get_mode(self)
+    cdef int count(self)
+    cdef void reload(self)
+    cdef int have_id(self)
diff --git a/kivy/graphics/vertex.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/vertex.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..ae96db4
Binary files /dev/null and b/kivy/graphics/vertex.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/vertex.pxd b/kivy/graphics/vertex.pxd
new file mode 100644
index 0000000..6794b29
--- /dev/null
+++ b/kivy/graphics/vertex.pxd
@@ -0,0 +1,20 @@
+from kivy.graphics.cgl cimport GLuint
+
+cdef struct vertex_t:
+    float x, y
+    float s0, t0
+
+ctypedef struct vertex_attr_t:
+    char *name
+    unsigned int index
+    unsigned int size
+    GLuint type
+    unsigned int bytesize
+    int per_vertex
+
+cdef class VertexFormat:
+    cdef vertex_attr_t *vattr
+    cdef long vattr_count
+    cdef unsigned int vsize
+    cdef unsigned int vbytesize
+    cdef object last_shader
diff --git a/kivy/graphics/vertex_instructions.cpython-310-x86_64-linux-gnu.so b/kivy/graphics/vertex_instructions.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..4ae7da4
Binary files /dev/null and b/kivy/graphics/vertex_instructions.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/graphics/vertex_instructions.pxd b/kivy/graphics/vertex_instructions.pxd
new file mode 100644
index 0000000..81ac343
--- /dev/null
+++ b/kivy/graphics/vertex_instructions.pxd
@@ -0,0 +1,34 @@
+from kivy.graphics.instructions cimport VertexInstruction
+from kivy.graphics.vertex cimport VertexFormat
+
+
+cdef class Bezier(VertexInstruction):
+    cdef list _points
+    cdef int _segments
+    cdef bint _loop
+    cdef int _dash_offset, _dash_length
+
+    cdef void build(self)
+
+
+cdef class StripMesh(VertexInstruction):
+    cdef int icount
+    cdef int li, lic
+    cdef int add_triangle_strip(self, float *vertices, int vcount, int icount,
+            int mode)
+
+
+cdef class Mesh(VertexInstruction):
+    cdef int is_built
+    cdef object _vertices  # the object the user passed in
+    cdef object _indices
+    cdef object _fvertices  # a buffer interface passed by user, or created
+    cdef object _lindices
+    cdef float *_pvertices  # the pointer to the start of buffer interface data
+    cdef unsigned short *_pindices
+    cdef VertexFormat vertex_format
+    cdef long vcount  # the length of last set _vertices
+    cdef long icount  # the length of last set _indices
+
+    cdef void build_triangle_fan(self, float *vertices, int vcount, int icount)
+    cdef void build(self)
diff --git a/kivy/graphics/vertex_instructions_line.pxi b/kivy/graphics/vertex_instructions_line.pxi
new file mode 100644
index 0000000..5c6e67d
--- /dev/null
+++ b/kivy/graphics/vertex_instructions_line.pxi
@@ -0,0 +1,1561 @@
+DEF LINE_CAP_NONE = 0
+DEF LINE_CAP_SQUARE = 1
+DEF LINE_CAP_ROUND = 2
+
+DEF LINE_JOINT_NONE = 0
+DEF LINE_JOINT_MITER = 1
+DEF LINE_JOINT_BEVEL = 2
+DEF LINE_JOINT_ROUND = 3
+
+DEF LINE_MODE_POINTS = 0
+DEF LINE_MODE_ELLIPSE = 1
+DEF LINE_MODE_CIRCLE = 2
+DEF LINE_MODE_RECTANGLE = 3
+DEF LINE_MODE_ROUNDED_RECTANGLE = 4
+DEF LINE_MODE_BEZIER = 5
+
+from kivy.graphics.stencil_instructions cimport StencilUse, StencilUnUse, StencilPush, StencilPop
+import itertools
+
+cdef float PI = <float>3.1415926535
+
+cdef inline int line_intersection(double x1, double y1, double x2, double y2,
+        double x3, double y3, double x4, double y4, double *px, double *py):
+    cdef double u = (x1 * y2 - y1 * x2)
+    cdef double v = (x3 * y4 - y3 * x4)
+    cdef double denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+    if denom == 0:
+        return 0
+    px[0] = (u * (x3 - x4) - (x1 - x2) * v) / denom
+    py[0] = (u * (y3 - y4) - (y1 - y2) * v) / denom
+    return 1
+
+cdef class Line(VertexInstruction):
+    '''A 2d line.
+
+    Drawing a line can be done easily::
+
+        with self.canvas:
+            Line(points=[100, 100, 200, 100, 100, 200], width=10)
+
+    The line has 3 internal drawing modes that you should be aware of
+    for optimal results:
+
+    #. If the :attr:`width` is 1.0, then the standard GL_LINE drawing from
+       OpenGL will be used. :attr:`dash_length`, :attr:`dash_offset`, and :attr:`dashes` will
+       work, while properties for cap and joint have no meaning here.
+    #. If the :attr:`width` is greater than 1.0, then a custom drawing method,
+       based on triangulation, will be used. :attr:`dash_length`,
+       :attr:`dash_offset`, and :attr:`dashes` do not work in this mode.
+       Additionally, if the current color has an alpha less than 1.0, a
+       stencil will be used internally to draw the line.
+
+    .. image:: images/line-instruction.png
+        :align: center
+
+    :Parameters:
+        `points`: list
+            List of points in the format (x1, y1, x2, y2...)
+        `dash_length`: int
+            Length of a segment (if dashed), defaults to 1.
+        `dash_offset`: int
+            Offset between the end of a segment and the beginning of the
+            next one, defaults to 0. Changing this makes it dashed.
+        `dashes`: list of ints
+            List of [ON length, offset, ON length, offset, ...]. E.g. ``[2,4,1,6,8,2]``
+            would create a line with the first dash length 2 then an offset of 4 then
+            a dash length of 1 then an offset of 6 and so on. Defaults to ``[]``.
+            Changing this makes it dashed and overrides `dash_length` and `dash_offset`.
+        `width`: float
+            Width of the line, defaults to 1.0.
+        `cap`: str, defaults to 'round'
+            See :attr:`cap` for more information.
+        `joint`: str, defaults to 'round'
+            See :attr:`joint` for more information.
+        `cap_precision`: int, defaults to 10
+            See :attr:`cap_precision` for more information
+        `joint_precision`: int, defaults to 10
+            See :attr:`joint_precision` for more information
+            See :attr:`cap_precision` for more information.
+        `joint_precision`: int, defaults to 10
+            See :attr:`joint_precision` for more information.
+        `close`: bool, defaults to False
+            If True, the line will be closed.
+        `circle`: list
+            If set, the :attr:`points` will be set to build a circle. See
+            :attr:`circle` for more information.
+        `ellipse`: list
+            If set, the :attr:`points` will be set to build an ellipse. See
+            :attr:`ellipse` for more information.
+        `rectangle`: list
+            If set, the :attr:`points` will be set to build a rectangle. See
+            :attr:`rectangle` for more information.
+        `bezier`: list
+            If set, the :attr:`points` will be set to build a bezier line. See
+            :attr:`bezier` for more information.
+        `bezier_precision`: int, defaults to 180
+            Precision of the Bezier drawing.
+
+    .. versionchanged:: 1.0.8
+        `dash_offset` and `dash_length` have been added.
+
+    .. versionchanged:: 1.4.1
+        `width`, `cap`, `joint`, `cap_precision`, `joint_precision`, `close`,
+        `ellipse`, `rectangle` have been added.
+
+    .. versionchanged:: 1.4.1
+        `bezier`, `bezier_precision` have been added.
+
+    .. versionchanged:: 1.11.0
+        `dashes` have been added
+
+    '''
+    cdef int _cap
+    cdef int _cap_precision
+    cdef int _joint_precision
+    cdef int _bezier_precision
+    cdef int _joint
+    cdef list _points
+    cdef list _dash_list
+    cdef float _width
+    cdef int _dash_offset, _dash_length
+    cdef int _use_stencil
+    cdef int _close
+    cdef int _mode
+    cdef Instruction _stencil_rect
+    cdef Instruction _stencil_push
+    cdef Instruction _stencil_use
+    cdef Instruction _stencil_unuse
+    cdef Instruction _stencil_pop
+    cdef double _bxmin, _bxmax, _bymin, _bymax
+    cdef tuple _mode_args
+
+    def __init__(self, **kwargs):
+        super(Line, self).__init__(**kwargs)
+        v = kwargs.get('points')
+        self.points = v if v is not None else []
+        self.dashes = kwargs.get('dashes', [])
+        self.batch.set_mode('line_strip')
+        self._dash_length = kwargs.get('dash_length') or 1
+        self._dash_offset = kwargs.get('dash_offset') or 0
+        self._width = kwargs.get('width') or 1.0
+        self.joint = kwargs.get('joint') or 'round'
+        self.cap = kwargs.get('cap') or 'round'
+        self._cap_precision = kwargs.get('cap_precision') or 10
+        self._joint_precision = kwargs.get('joint_precision') or 10
+        self._bezier_precision = kwargs.get('bezier_precision') or 180
+        self._close = int(bool(kwargs.get('close', 0)))
+        self._stencil_rect = None
+        self._stencil_push = None
+        self._stencil_use = None
+        self._stencil_unuse = None
+        self._stencil_pop = None
+        self._use_stencil = 0
+
+        if 'ellipse' in kwargs:
+            self.ellipse = kwargs['ellipse']
+        if 'circle' in kwargs:
+            self.circle = kwargs['circle']
+        if 'rectangle' in kwargs:
+            self.rectangle = kwargs['rectangle']
+        if 'rounded_rectangle' in kwargs:
+            self.rounded_rectangle = kwargs['rounded_rectangle']
+        if 'bezier' in kwargs:
+            self.bezier = kwargs['bezier']
+
+    cdef void build(self):
+        if self._mode == LINE_MODE_ELLIPSE:
+            self.prebuild_ellipse()
+        elif self._mode == LINE_MODE_CIRCLE:
+            self.prebuild_circle()
+        elif self._mode == LINE_MODE_RECTANGLE:
+            self.prebuild_rectangle()
+        elif self._mode == LINE_MODE_ROUNDED_RECTANGLE:
+            self.prebuild_rounded_rectangle()
+        elif self._mode == LINE_MODE_BEZIER:
+            self.prebuild_bezier()
+        if self._width == 1.0:
+            self.build_legacy()
+        else:
+            self.build_extended()
+
+    cdef void ensure_stencil(self):
+        if self._stencil_rect == None:
+            self._stencil_rect = Rectangle()
+            self._stencil_push = StencilPush()
+            self._stencil_pop = StencilPop()
+            self._stencil_use = StencilUse(op='lequal')
+            self._stencil_unuse = StencilUnUse()
+
+    cdef int apply(self) except -1:
+        if self._width == 1.:
+            VertexInstruction.apply(self)
+            return 0
+
+        cdef double alpha = getActiveContext()['color'][-1]
+        self._use_stencil = alpha < 1
+        if self._use_stencil:
+            self.ensure_stencil()
+
+            self._stencil_push.apply()
+            VertexInstruction.apply(self)
+            self._stencil_use.apply()
+            self._stencil_rect.pos = self._bxmin, self._bymin
+            self._stencil_rect.size = self._bxmax - self._bxmin, self._bymax - self._bymin
+            self._stencil_rect.apply()
+            self._stencil_unuse.apply()
+            VertexInstruction.apply(self)
+            self._stencil_pop.apply()
+        else:
+            VertexInstruction.apply(self)
+        return 0
+
+    cdef void build_legacy(self):
+        cdef int i
+        cdef long count = <int>int(len(self.points) / 2.)
+        cdef list p = self.points
+        cdef vertex_t *vertices = NULL
+        cdef unsigned short *indices = NULL
+        cdef float tex_x
+        cdef char *buf = NULL
+        cdef Texture texture = self.texture
+        cdef int length = 0
+        cdef int position = 0
+        cdef int val
+
+        if count < 2:
+            self.batch.clear_data()
+            return
+
+        if self._close:
+            p = p + [p[0], p[1]]
+            count += 1
+
+        self.batch.set_mode('line_strip')
+
+        if self._dash_list:
+            length = sum(self._dash_list)
+            if texture is None or texture._width != length \
+                or texture._height != 1:
+                self.texture = texture = Texture.create(size=(length, 1))
+                texture.wrap = 'repeat'
+
+            # create a buffer to fill our texture
+            buf = <char *>malloc(4 * length)
+            memset(buf, 0, 4 * length)
+
+            for idx, val in enumerate(self._dash_list):
+                if idx % 2 == 0:
+                    memset(buf + position, 255, val * 4)
+                position += val * 4
+
+            p_str = buf[:position]
+            try:
+                self.texture.blit_buffer(p_str, colorfmt='rgba', bufferfmt='ubyte')
+            finally:
+                free(buf)
+        elif self._dash_offset != 0:
+            length = self._dash_length + self._dash_offset
+            if texture is None or texture._width != \
+                (self._dash_length + self._dash_offset) or \
+                texture._height != 1:
+
+                self.texture = texture = Texture.create(
+                        size=(self._dash_length + self._dash_offset, 1))
+                texture.wrap = 'repeat'
+
+            # create a buffer to fill our texture
+            buf = <char *>malloc(4 * (self._dash_length + self._dash_offset))
+            memset(buf, 255, self._dash_length * 4)
+            memset(buf + self._dash_length * 4, 0, self._dash_offset * 4)
+            p_str = buf[:(self._dash_length + self._dash_offset) * 4]
+
+            try:
+                self.texture.blit_buffer(p_str, colorfmt='rgba', bufferfmt='ubyte')
+            finally:
+                free(buf)
+
+        elif texture is not None:
+            self.texture = None
+
+        vertices = <vertex_t *>malloc(count * sizeof(vertex_t))
+        if vertices == NULL:
+            raise MemoryError('vertices')
+
+        indices = <unsigned short *>malloc(count * sizeof(unsigned short))
+        if indices == NULL:
+            free(vertices)
+            raise MemoryError('indices')
+
+        tex_x = 0
+        for i in range(count):
+            if (self._dash_offset != 0 or self._dash_list) and i > 0:
+                tex_x += <float>(sqrt(
+                        pow(p[i * 2]     - p[(i - 1) * 2], 2)  +
+                        pow(p[i * 2 + 1] - p[(i - 1) * 2 + 1], 2)) / length)
+
+                vertices[i].s0 = tex_x
+                vertices[i].t0 = 0
+
+            vertices[i].x = p[i * 2]
+            vertices[i].y = p[i * 2 + 1]
+            indices[i] = i
+
+        self.batch.set_data(vertices, <int>count, indices, <int>count)
+
+        free(vertices)
+        free(indices)
+
+    cdef void build_extended(self):
+        cdef int i, j
+        cdef long count = <int>int(len(self.points) / 2.)
+        cdef list p = self.points
+        cdef vertex_t *vertices = NULL
+        cdef unsigned short *indices = NULL
+        cdef float tex_x
+        cdef int cap
+        cdef char *buf = NULL
+        self.texture = None
+
+        self._bxmin = 999999999
+        self._bymin = 999999999
+        self._bxmax = -999999999
+        self._bymax = -999999999
+
+        if count < 2:
+            self.batch.clear_data()
+            return
+
+        cap = self._cap
+        if self._close and count > 2:
+            p = p + p[0:4]
+            count += 2
+            cap = LINE_CAP_NONE
+
+        self.batch.set_mode('triangles')
+        cdef unsigned long vertices_count = (count - 1) * 4
+        cdef unsigned long indices_count = (count - 1) * 6
+        cdef unsigned int iv = 0, ii = 0, siv = 0
+
+        if self._joint == LINE_JOINT_BEVEL:
+            indices_count += (count - 2) * 3
+            vertices_count += (count - 2)
+        elif self._joint == LINE_JOINT_ROUND:
+            indices_count += (self._joint_precision * 3) * (count - 2)
+            vertices_count += (self._joint_precision) * (count - 2)
+        elif self._joint == LINE_JOINT_MITER:
+            indices_count += (count - 2) * 6
+            vertices_count += (count - 2) * 2
+
+        if cap == LINE_CAP_SQUARE:
+            indices_count += 12
+            vertices_count += 4
+        elif cap == LINE_CAP_ROUND:
+            indices_count += (self._cap_precision * 3) * 2
+            vertices_count += (self._cap_precision) * 2
+
+        vertices = <vertex_t *>malloc(vertices_count * sizeof(vertex_t))
+        if vertices == NULL:
+            raise MemoryError('vertices')
+
+        indices = <unsigned short *>malloc(indices_count * sizeof(unsigned short))
+        if indices == NULL:
+            free(vertices)
+            raise MemoryError('indices')
+
+        cdef double ax, ay, bx, _by, cx, cy, angle, a1, a2
+        cdef double x1, y1, x2, y2, x3, y3, x4, y4
+        cdef double sx1, sy1, sx4, sy4, sangle
+        cdef double pcx, pcy, px1, py1, px2, py2, px3, py3, px4, py4, pangle = 0, pangle2
+        cdef double w = self._width
+        cdef double ix, iy
+        cdef unsigned int piv, pii2, piv2, skip = 0
+        cdef double jangle
+        angle = sangle = 0
+        piv = pcx = pcy = cx = cy = ii = iv = ix = iy = 0
+        px1 = px2 = px3 = px4 = py1 = py2 = py3 = py4 = 0
+        sx1 = sy1 = sx4 = sy4 = 0
+        x1 = x2 = x3 = x4 = y1 = y2 = y3 = y4 = 0
+        cdef double cos1 = 0, cos2 = 0, sin1 = 0, sin2 = 0
+        for i in range(0, count - 1):
+            ax = p[i * 2]
+            ay = p[i * 2 + 1]
+            bx = p[i * 2 + 2]
+            _by = p[i * 2 + 3]
+
+            if (ax, ay) == (bx, _by):
+                skip += 1
+                continue
+
+            if i - skip > 0 and self._joint != LINE_JOINT_NONE:
+                pcx = cx
+                pcy = cy
+                px1 = x1
+                px2 = x2
+                px3 = x3
+                px4 = x4
+                py1 = y1
+                py2 = y2
+                py3 = y3
+                py4 = y4
+
+            piv2 = piv
+            piv = iv
+            pangle2 = pangle
+            pangle = angle
+
+            # calculate the orientation of the segment, between pi and -pi
+            cx = bx - ax
+            cy = _by - ay
+            angle = atan2(cy, cx)
+            a1 = angle - PI2
+            a2 = angle + PI2
+
+            # calculate the position of the segment
+            cos1 = cos(a1) * w
+            sin1 = sin(a1) * w
+            cos2 = cos(a2) * w
+            sin2 = sin(a2) * w
+            x1 = ax + cos1
+            y1 = ay + sin1
+            x4 = ax + cos2
+            y4 = ay + sin2
+            x2 = bx + cos1
+            y2 = _by + sin1
+            x3 = bx + cos2
+            y3 = _by + sin2
+
+            if i - skip == 0:
+                sx1 = x1
+                sy1 = y1
+                sx4 = x4
+                sy4 = y4
+                sangle = angle
+
+            indices[ii    ] = iv
+            indices[ii + 1] = iv + 1
+            indices[ii + 2] = iv + 2
+            indices[ii + 3] = iv
+            indices[ii + 4] = iv + 2
+            indices[ii + 5] = iv + 3
+            ii += 6
+
+            vertices[iv].x = <float>x1
+            vertices[iv].y = <float>y1
+            vertices[iv].s0 = 0
+            vertices[iv].t0 = 0
+            iv += 1
+            vertices[iv].x = <float>x2
+            vertices[iv].y = <float>y2
+            vertices[iv].s0 = 1
+            vertices[iv].t0 = 0
+            iv += 1
+            vertices[iv].x = <float>x3
+            vertices[iv].y = <float>y3
+            vertices[iv].s0 = 1
+            vertices[iv].t0 = 1
+            iv += 1
+            vertices[iv].x = <float>x4
+            vertices[iv].y = <float>y4
+            vertices[iv].s0 = 0
+            vertices[iv].t0 = 1
+            iv += 1
+
+            # joint generation
+            if i - skip == 0 or self._joint == LINE_JOINT_NONE:
+                continue
+
+            # calculate the angle of the previous and current segment
+            jangle = atan2(
+                cx * pcy - cy * pcx,
+                cx * pcx + cy * pcy)
+
+            # in case of the angle is NULL, avoid the generation
+            if jangle == 0:
+                if self._joint == LINE_JOINT_ROUND:
+                    vertices_count -= self._joint_precision
+                    indices_count -= self._joint_precision * 3
+                elif self._joint == LINE_JOINT_BEVEL:
+                    vertices_count -= 1
+                    indices_count -= 3
+                elif self._joint == LINE_JOINT_MITER:
+                    vertices_count -= 2
+                    indices_count -= 6
+                continue
+
+            if self._joint == LINE_JOINT_BEVEL:
+                vertices[iv].x = <float>ax
+                vertices[iv].y = <float>ay
+                vertices[iv].s0 = 0
+                vertices[iv].t0 = 0
+                if jangle < 0:
+                    indices[ii] = piv2 + 1
+                    indices[ii + 1] = piv
+                    indices[ii + 2] = iv
+                else:
+                    indices[ii] = piv2 + 2
+                    indices[ii + 1] = piv + 3
+                    indices[ii + 2] = iv
+                ii += 3
+                iv += 1
+
+            elif self._joint == LINE_JOINT_MITER:
+                vertices[iv].x = <float>ax
+                vertices[iv].y = <float>ay
+                vertices[iv].s0 = 0
+                vertices[iv].t0 = 0
+                if jangle < 0:
+                    if line_intersection(px1, py1, px2, py2, x1, y1, x2, y2, &ix, &iy) == 0:
+                        vertices_count -= 2
+                        indices_count -= 6
+                        continue
+                    vertices[iv + 1].x = <float>ix
+                    vertices[iv + 1].y = <float>iy
+                    vertices[iv + 1].s0 = 0
+                    vertices[iv + 1].t0 = 0
+                    indices[ii] = iv
+                    indices[ii + 1] = iv + 1
+                    indices[ii + 2] = piv2 + 1
+                    indices[ii + 3] = iv
+                    indices[ii + 4] = piv
+                    indices[ii + 5] = iv + 1
+                    ii += 6
+                    iv += 2
+                else:
+                    if line_intersection(px3, py3, px4, py4, x3, y3, x4, y4, &ix, &iy) == 0:
+                        vertices_count -= 2
+                        indices_count -= 6
+                        continue
+                    vertices[iv + 1].x = <float>ix
+                    vertices[iv + 1].y = <float>iy
+                    vertices[iv + 1].s0 = 0
+                    vertices[iv + 1].t0 = 0
+                    indices[ii] = iv
+                    indices[ii + 1] = iv + 1
+                    indices[ii + 2] = piv2 + 2
+                    indices[ii + 3] = iv
+                    indices[ii + 4] = piv + 3
+                    indices[ii + 5] = iv + 1
+                    ii += 6
+                    iv += 2
+
+            elif self._joint == LINE_JOINT_ROUND:
+
+                # cap end
+                if jangle < 0:
+                    a1 = pangle2 - PI2
+                    a2 = angle + PI2
+                    a0 = a2
+                    step = (abs(jangle)) / float(self._joint_precision)
+                    pivstart = piv + 3
+                    pivend = piv2 + 1
+                else:
+                    a1 = angle - PI2
+                    a2 = pangle2 + PI2
+                    a0 = a1
+                    step = -(abs(jangle)) / float(self._joint_precision)
+                    pivstart = piv
+                    pivend = piv2 + 2
+                siv = iv
+                vertices[iv].x = <float>ax
+                vertices[iv].y = <float>ay
+                vertices[iv].s0 = 0
+                vertices[iv].t0 = 0
+                iv += 1
+                for j in xrange(0, self._joint_precision - 1):
+                    vertices[iv].x = <float>(ax - cos(a0 - step * j) * w)
+                    vertices[iv].y = <float>(ay - sin(a0 - step * j) * w)
+                    vertices[iv].s0 = 0
+                    vertices[iv].t0 = 0
+                    if j == 0:
+                        indices[ii] = siv
+                        indices[ii + 1] = <unsigned short>pivstart
+                        indices[ii + 2] = iv
+                    else:
+                        indices[ii] = siv
+                        indices[ii + 1] = iv - 1
+                        indices[ii + 2] = iv
+                    iv += 1
+                    ii += 3
+                indices[ii] = siv
+                indices[ii + 1] = iv - 1
+                indices[ii + 2] = <unsigned short>pivend
+                ii += 3
+
+        # caps
+        if cap == LINE_CAP_SQUARE:
+            vertices[iv].x = <float>(x2 + cos(angle) * w)
+            vertices[iv].y = <float>(y2 + sin(angle) * w)
+            vertices[iv].s0 = 0
+            vertices[iv].t0 = 0
+            vertices[iv + 1].x = <float>(x3 + cos(angle) * w)
+            vertices[iv + 1].y = <float>(y3 + sin(angle) * w)
+            vertices[iv + 1].s0 = 0
+            vertices[iv + 1].t0 = 0
+            indices[ii] = piv + 1
+            indices[ii + 1] = piv + 2
+            indices[ii + 2] = iv + 1
+            indices[ii + 3] = piv + 1
+            indices[ii + 4] = iv
+            indices[ii + 5] = iv + 1
+            ii += 6
+            iv += 2
+            vertices[iv].x = <float>(sx1 - cos(sangle) * w)
+            vertices[iv].y = <float>(sy1 - sin(sangle) * w)
+            vertices[iv].s0 = 0
+            vertices[iv].t0 = 0
+            vertices[iv + 1].x = <float>(sx4 - cos(sangle) * w)
+            vertices[iv + 1].y = <float>(sy4 - sin(sangle) * w)
+            vertices[iv + 1].s0 = 0
+            vertices[iv + 1].t0 = 0
+            indices[ii] = 0
+            indices[ii + 1] = 3
+            indices[ii + 2] = iv + 1
+            indices[ii + 3] = 0
+            indices[ii + 4] = iv
+            indices[ii + 5] = iv + 1
+            ii += 6
+            iv += 2
+
+        elif cap == LINE_CAP_ROUND:
+
+            # cap start
+            a1 = sangle - PI2
+            a2 = sangle + PI2
+            step = (a1 - a2) / float(self._cap_precision)
+            siv = iv
+            cx = p[0]
+            cy = p[1]
+            vertices[iv].x = <float>cx
+            vertices[iv].y = <float>cy
+            vertices[iv].s0 = 0
+            vertices[iv].t0 = 0
+            iv += 1
+            for i in xrange(0, self._cap_precision - 1):
+                vertices[iv].x = <float>(cx + cos(a1 + step * i) * w)
+                vertices[iv].y = <float>(cy + sin(a1 + step * i) * w)
+                vertices[iv].s0 = 1
+                vertices[iv].t0 = 1
+                if i == 0:
+                    indices[ii] = siv
+                    indices[ii + 1] = 0
+                    indices[ii + 2] = iv
+                else:
+                    indices[ii] = siv
+                    indices[ii + 1] = iv - 1
+                    indices[ii + 2] = iv
+                iv += 1
+                ii += 3
+            indices[ii] = siv
+            indices[ii + 1] = iv - 1
+            indices[ii + 2] = 3
+            ii += 3
+
+            # cap end
+            a1 = angle - PI2
+            a2 = angle + PI2
+            step = (a2 - a1) / float(self._cap_precision)
+            siv = iv
+            cx = p[-2]
+            cy = p[-1]
+            vertices[iv].x = <float>cx
+            vertices[iv].y = <float>cy
+            vertices[iv].s0 = 0
+            vertices[iv].t0 = 0
+            iv += 1
+            for i in xrange(0, self._cap_precision - 1):
+                vertices[iv].x = <float>(cx + cos(a1 + step * i) * w)
+                vertices[iv].y = <float>(cy + sin(a1 + step * i) * w)
+                vertices[iv].s0 = 0
+                vertices[iv].t0 = 0
+                if i == 0:
+                    indices[ii] = siv
+                    indices[ii + 1] = piv + 1
+                    indices[ii + 2] = iv
+                else:
+                    indices[ii] = siv
+                    indices[ii + 1] = iv - 1
+                    indices[ii + 2] = iv
+                iv += 1
+                ii += 3
+            indices[ii] = siv
+            indices[ii + 1] = iv - 1
+            indices[ii + 2] = piv + 2
+            ii += 3
+
+        while ii < indices_count:
+            # make all the remaining indices point to the last vertice
+            indices[ii] = siv
+            ii += 1
+
+        # compute bbox
+        cdef unsigned long iul
+        for iul in xrange(vertices_count):
+            if vertices[iul].x < self._bxmin:
+                self._bxmin = vertices[iul].x
+            if vertices[iul].x > self._bxmax:
+                self._bxmax = vertices[iul].x
+            if vertices[iul].y < self._bymin:
+                self._bymin = vertices[iul].y
+            if vertices[iul].y > self._bymax:
+                self._bymax = vertices[iul].y
+
+        self.batch.set_data(vertices, <int>vertices_count,
+                           indices, <int>indices_count)
+
+        free(vertices)
+        free(indices)
+
+    property points:
+        '''Property for getting/settings points of the line
+
+        .. warning::
+
+            This will always reconstruct the whole graphics from the new points
+            list. It can be very CPU expensive.
+        '''
+        def __get__(self):
+            return self._points
+
+        def __set__(self, points):
+            if points and isinstance(points[0], (list, tuple)):
+                self._points = list(itertools.chain(*points))
+            else:
+                self._points = list(points)
+
+            self._mode = LINE_MODE_POINTS
+            self.flag_data_update()
+
+    property dash_length:
+        '''Property for getting/setting the length of the dashes in the curve
+
+        .. versionadded:: 1.0.8
+        '''
+        def __get__(self):
+            return self._dash_length
+
+        def __set__(self, value):
+            if value < 0:
+                raise GraphicException('Invalid dash_length value, must be >= 0')
+            self._dash_length = value
+            self.flag_data_update()
+
+    property dash_offset:
+        '''Property for getting/setting the offset between the dashes in the curve
+
+        .. versionadded:: 1.0.8
+        '''
+        def __get__(self):
+            return self._dash_offset
+
+        def __set__(self, value):
+            if value < 0:
+                raise GraphicException('Invalid dash_offset value, must be >= 0')
+            self._dash_offset = value
+            self.flag_data_update()
+
+    property dashes:
+        '''Property for getting/setting ``dashes``.
+
+        List of [ON length, offset, ON length, offset, ...]. E.g. ``[2,4,1,6,8,2]``
+        would create a line with the first dash length 2 then an offset of 4 then
+        a dash length of 1 then an offset of 6 and so on.
+
+        .. versionadded:: 1.11.0
+        '''
+        def __get__(self):
+            return self._dash_list
+
+        def __set__(self, value):
+            self._dash_list = list(value)
+            self.flag_data_update()
+
+    property width:
+        '''Determine the width of the line, defaults to 1.0.
+
+        .. versionadded:: 1.4.1
+        '''
+        def __get__(self):
+            return self._width
+
+        def __set__(self, value):
+            if value <= 0:
+                raise GraphicException('Invalid width value, must be > 0')
+            self._width = value
+            self.flag_data_update()
+
+    property cap:
+        '''Determine the cap of the line, defaults to 'round'. Can be one of
+        'none', 'square' or 'round'
+
+        .. versionadded:: 1.4.1
+        '''
+        def __get__(self):
+            if self._cap == LINE_CAP_SQUARE:
+                return 'square'
+            elif self._cap == LINE_CAP_ROUND:
+                return 'round'
+            return 'none'
+
+        def __set__(self, value):
+            if value not in ('none', 'square', 'round'):
+                raise GraphicException('Invalid cap, must be one of '
+                        '"none", "square", "round"')
+            if value == 'square':
+                self._cap = LINE_CAP_SQUARE
+            elif value == 'round':
+                self._cap = LINE_CAP_ROUND
+            else:
+                self._cap = LINE_CAP_NONE
+            self.flag_data_update()
+
+    property joint:
+        '''Determine the join of the line, defaults to 'round'. Can be one of
+        'none', 'round', 'bevel', 'miter'.
+
+        .. versionadded:: 1.4.1
+        '''
+
+        def __get__(self):
+            if self._joint == LINE_JOINT_ROUND:
+                return 'round'
+            elif self._joint == LINE_JOINT_BEVEL:
+                return 'bevel'
+            elif self._joint == LINE_JOINT_MITER:
+                return 'miter'
+            return 'none'
+
+        def __set__(self, value):
+            if value not in ('none', 'miter', 'bevel', 'round'):
+                raise GraphicException('Invalid joint, must be one of '
+                    '"none", "miter", "bevel", "round"')
+            if value == 'round':
+                self._joint = LINE_JOINT_ROUND
+            elif value == 'bevel':
+                self._joint = LINE_JOINT_BEVEL
+            elif value == 'miter':
+                self._joint = LINE_JOINT_MITER
+            else:
+                self._joint = LINE_JOINT_NONE
+            self.flag_data_update()
+
+    property cap_precision:
+        '''Number of iteration for drawing the "round" cap, defaults to 10.
+        The cap_precision must be at least 1.
+
+        .. versionadded:: 1.4.1
+        '''
+
+        def __get__(self):
+            return self._cap_precision
+
+        def __set__(self, value):
+            if value < 1:
+                raise GraphicException('Invalid cap_precision value, must be >= 1')
+            self._cap_precision = int(value)
+            self.flag_data_update()
+
+    property joint_precision:
+        '''Number of iteration for drawing the "round" joint, defaults to 10.
+        The joint_precision must be at least 1.
+
+        .. versionadded:: 1.4.1
+        '''
+
+        def __get__(self):
+            return self._joint_precision
+
+        def __set__(self, value):
+            if value < 1:
+                raise GraphicException('Invalid joint_precision value, must be >= 1')
+            self._joint_precision = int(value)
+            self.flag_data_update()
+
+    property close:
+        '''If True, the line will be closed.
+
+        .. versionadded:: 1.4.1
+        '''
+
+        def __get__(self):
+            return self._close
+
+        def __set__(self, value):
+            self._close = int(bool(value))
+            self.flag_data_update()
+
+    property ellipse:
+        '''Use this property to build an ellipse, without calculating the
+        :attr:`points`. You can only set this property, not get it.
+
+        The argument must be a tuple of (x, y, width, height, angle_start,
+        angle_end, segments):
+
+        * x and y represent the bottom left of the ellipse
+        * width and height represent the size of the ellipse
+        * (optional) angle_start and angle_end are in degree. The default
+          value is 0 and 360.
+        * (optional) segments is the precision of the ellipse. The default
+          value is calculated from the range between angle.
+
+        Note that it's up to you to :attr:`close` the ellipse or not.
+
+        For example, for building a simple ellipse, in python::
+
+            # simple ellipse
+            Line(ellipse=(0, 0, 150, 150))
+
+            # only from 90 to 180 degrees
+            Line(ellipse=(0, 0, 150, 150, 90, 180))
+
+            # only from 90 to 180 degrees, with few segments
+            Line(ellipse=(0, 0, 150, 150, 90, 180, 20))
+
+        .. versionadded:: 1.4.1
+        '''
+
+        def __set__(self, args):
+            if args == None:
+                raise GraphicException(
+                        'Invalid ellipse value: {0!r}'.format(args))
+            if len(args) not in (4, 6, 7):
+                raise GraphicException('Invalid number of arguments: '
+                        '{0} instead of 4, 6 or 7.'.format(len(args)))
+            self._mode_args = tuple(args)
+            self._mode = LINE_MODE_ELLIPSE
+            self.flag_data_update()
+
+    cdef void prebuild_ellipse(self):
+        cdef double x, y, w, h, angle_start = 0, angle_end = 360
+        cdef int angle_dir, segments = 0
+        cdef double angle_range
+        cdef tuple args = self._mode_args
+
+        if len(args) == 4:
+            x, y, w, h = args
+        elif len(args) == 6:
+            x, y, w, h, angle_start, angle_end = args
+        elif len(args) == 7:
+            x, y, w, h, angle_start, angle_end, segments = args
+            segments += 2
+        else:
+            x = y = w = h = 0
+            assert(0)
+
+        if angle_end > angle_start:
+            angle_dir = 1
+        else:
+            angle_dir = -1
+        if segments == 0:
+            segments = int(abs(angle_end - angle_start) / 2) + 3
+            if segments % 2 == 1:
+                segments += 1
+        # rad = deg * (pi / 180), where pi/180 = 0.0174...
+        angle_start = angle_start * 0.017453292519943295
+        angle_end = angle_end * 0.017453292519943295
+        angle_range = abs(angle_end - angle_start) / (segments - 2)
+
+        cdef list points = [0, ] * segments
+        cdef double angle
+        cdef double rx = w * 0.5
+        cdef double ry = h * 0.5
+        for i in xrange(0, segments, 2):
+            angle = angle_start + (angle_dir * (i - 1) * angle_range)
+            points[i] = (x + rx) + (rx * sin(angle))
+            points[i + 1] = (y + ry) + (ry * cos(angle))
+
+        self._points = points
+
+
+    property circle:
+        '''Use this property to build a circle, without calculating the
+        :attr:`points`. You can only set this property, not get it.
+
+        The argument must be a tuple of (center_x, center_y, radius, angle_start,
+        angle_end, segments):
+
+        * center_x and center_y represent the center of the circle
+        * radius represent the radius of the circle
+        * (optional) angle_start and angle_end are in degree. The default
+          value is 0 and 360.
+        * (optional) segments is the precision of the ellipse. The default
+          value is calculated from the range between angle.
+
+        Note that it's up to you to :attr:`close` the circle or not.
+
+        For example, for building a simple ellipse, in python::
+
+            # simple circle
+            Line(circle=(150, 150, 50))
+
+            # only from 90 to 180 degrees
+            Line(circle=(150, 150, 50, 90, 180))
+
+            # only from 90 to 180 degrees, with few segments
+            Line(circle=(150, 150, 50, 90, 180, 20))
+
+        .. versionadded:: 1.4.1
+        '''
+
+        def __set__(self, args):
+            if args == None:
+                raise GraphicException(
+                        'Invalid circle value: {0!r}'.format(args))
+            if len(args) not in (3, 5, 6):
+                raise GraphicException('Invalid number of arguments: '
+                        '{0} instead of 3, 5 or 6.'.format(len(args)))
+            self._mode_args = tuple(args)
+            self._mode = LINE_MODE_CIRCLE
+            self.flag_data_update()
+
+    cdef void prebuild_circle(self):
+        cdef double x, y, r, angle_start = 0, angle_end = 360
+        cdef int angle_dir, segments = 0
+        cdef double angle_range
+        cdef tuple args = self._mode_args
+
+        if len(args) == 3:
+            x, y, r = args
+        elif len(args) == 5:
+            x, y, r, angle_start, angle_end = args
+        elif len(args) == 6:
+            x, y, r, angle_start, angle_end, segments = args
+            segments += 1
+        else:
+            x = y = r = 0
+            assert(0)
+
+        if angle_end > angle_start:
+            angle_dir = 1
+        else:
+            angle_dir = -1
+        if segments == 0:
+            segments = int(abs(angle_end - angle_start) / 2) + 3
+
+        segmentpoints = segments * 2
+
+        # rad = deg * (pi / 180), where pi/180 = 0.0174...
+        angle_start = angle_start * 0.017453292519943295
+        angle_end = angle_end * 0.017453292519943295
+        angle_range = abs(angle_end - angle_start) / (segmentpoints - 2)
+
+        cdef list points = [0, ] * segmentpoints
+        cdef double angle
+        for i in xrange(0, segmentpoints, 2):
+            angle = angle_start + (angle_dir * i * angle_range)
+            points[i] = x + (r * sin(angle))
+            points[i + 1] = y + (r * cos(angle))
+        self._points = points
+
+    property rectangle:
+        '''Use this property to build a rectangle, without calculating the
+        :attr:`points`. You can only set this property, not get it.
+
+        The argument must be a tuple of (x, y, width, height):
+
+        * x and y represent the bottom-left position of the rectangle
+        * width and height represent the size
+
+        The line is automatically closed.
+
+        Usage::
+
+            Line(rectangle=(0, 0, 200, 200))
+
+        .. versionadded:: 1.4.1
+        '''
+
+        def __set__(self, args):
+            if args == None:
+                raise GraphicException(
+                        'Invalid rectangle value: {0!r}'.format(args))
+            if len(args) != 4:
+                raise GraphicException('Invalid number of arguments: '
+                        '{0} instead of 4.'.format(len(args)))
+            self._mode_args = tuple(args)
+            self._mode = LINE_MODE_RECTANGLE
+            self.flag_data_update()
+
+    cdef void prebuild_rectangle(self):
+        cdef double x, y, width, height
+        cdef int angle_dir, segments = 0
+        cdef double angle_range
+        cdef tuple args = self._mode_args
+
+        if args == None:
+            raise GraphicException(
+                    'Invalid ellipse value: {0!r}'.format(args))
+
+        if len(args) == 4:
+            x, y, width, height = args
+        else:
+            x = y = width = height = 0
+            assert(0)
+
+        self._points = [x, y, x + width, y, x + width, y + height, x, y + height]
+        self._close = 1
+
+    property rounded_rectangle:
+        '''Use this property to build a rectangle, without calculating the
+        :attr:`points`. You can only set this property, not get it.
+
+        The argument must be a tuple of one of the following forms:
+
+        * (x, y, width, height, corner_radius)
+        * (x, y, width, height, corner_radius, resolution)
+        * (x, y, width, height, corner_radius1, corner_radius2, corner_radius3, corner_radius4)
+        * (x, y, width, height, corner_radius1, corner_radius2, corner_radius3, corner_radius4, resolution)
+
+        * x and y represent the bottom-left position of the rectangle
+        * width and height represent the size
+        * corner_radius is the number of pixels between two borders and the center of the circle arc joining them
+        * resolution is the number of line segment that will be used to draw the circle arc at each corner (defaults to 30)
+
+        The line is automatically closed.
+
+        Usage::
+
+            Line(rounded_rectangle=(0, 0, 200, 200, 10, 20, 30, 40, 100))
+
+        .. versionadded:: 1.9.0
+        '''
+        def __set__(self, args):
+            if args == None:
+                raise GraphicException(
+                    'Invlid rounded rectangle value: {0!r}'.format(args))
+            if len(args) not in (5, 6, 8, 9):
+                raise GraphicException('invalid number of arguments:'
+                        '{0} not in (5, 6, 8, 9)'.format(len(args)))
+            self._mode_args = tuple(args)
+            self._mode = LINE_MODE_ROUNDED_RECTANGLE
+            self.flag_data_update()
+
+    cdef void prebuild_rounded_rectangle(self):
+        cdef float a, px, py, x, y, w, h, c1, c2, c3, c4
+        cdef resolution = 30
+        cdef int l = <int>len(self._mode_args)
+
+        self._points = []
+        a = <float>-PI
+        x, y, w, h = self._mode_args [:4]
+
+        if l == 5:
+            c1 = c2 = c3 = c4 = self._mode_args[4]
+        elif l == 6:
+            c1 = c2 = c3 = c4 = self._mode_args[4]
+            resolution = self._mode_args[5]
+        elif l == 8:
+            c1, c2, c3, c4 = self._mode_args[4:]
+        else:  # l == 9, but else make the compiler happy about uninitialization
+            c1, c2, c3, c4 = self._mode_args[4:8]
+            resolution = self._mode_args[8]
+
+        px = x + c1
+        py = y + c1
+
+        while a < - PI / 2.:
+            a += pi / resolution
+            self._points.extend([
+                px + cos(a) * c1,
+                py + sin(a) * c1])
+
+        px = x + w - c2
+        py = y + c2
+
+        while a < 0:
+            a += PI / resolution
+            self._points.extend([
+                px + cos(a) * c2,
+                py + sin(a) * c2])
+
+        px = x + w - c3
+        py = y + h - c3
+
+        while a < PI / 2.:
+            a += PI / resolution
+            self._points.extend([
+                px + cos(a) * c3,
+                py + sin(a) * c3])
+
+        px = x + c4
+        py = y + h - c4
+
+        while a < PI:
+            a += PI / resolution
+            self._points.extend([
+                px + cos(a) * c4,
+                py + sin(a) * c4])
+
+        self._close = 1
+
+    property bezier:
+        '''Use this property to build a bezier line, without calculating the
+        :attr:`points`. You can only set this property, not get it.
+
+        The argument must be a tuple of 2n elements, n being the number of points.
+
+        Usage::
+
+            Line(bezier=(x1, y1, x2, y2, x3, y3)
+
+        .. versionadded:: 1.4.2
+
+        .. note:: Bezier lines calculations are inexpensive for a low number of
+            points, but complexity is quadratic, so lines with a lot of points
+            can be very expensive to build, use with care!
+        '''
+
+        def __set__(self, args):
+            if args == None or len(args) % 2:
+                raise GraphicException(
+                        'Invalid bezier value: {0!r}'.format(args))
+            self._mode_args = tuple(args)
+            self._mode = LINE_MODE_BEZIER
+            self.flag_data_update()
+
+    cdef void prebuild_bezier(self):
+        cdef double x, y, l
+        cdef int segments = self._bezier_precision
+        cdef list T = list(self._mode_args)[:]
+
+        self._points = []
+        for x in xrange(segments):
+            l = x / (1.0 * segments)
+            # http://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm
+            # as the list is in the form of (x1, y1, x2, y2...) iteration is
+            # done on each item and the current item (xn or yn) in the list is
+            # replaced with a calculation of "xn + x(n+1) - xn" x(n+1) is
+            # placed at n+2. Each iteration makes the list one item shorter
+            for i in range(1, len(T)):
+                for j in xrange(len(T) - 2*i):
+                    T[j] = T[j] + (T[j+2] - T[j]) * l
+
+            # we got the coordinates of the point in T[0] and T[1]
+            self._points.append(T[0])
+            self._points.append(T[1])
+
+        # add one last point to join the curve to the end
+        self._points.append(T[-2])
+        self._points.append(T[-1])
+
+    property bezier_precision:
+        '''Number of iteration for drawing the bezier between 2 segments,
+        defaults to 180. The bezier_precision must be at least 1.
+
+        .. versionadded:: 1.4.2
+        '''
+
+        def __get__(self):
+            return self._bezier_precision
+
+        def __set__(self, value):
+            if value < 1:
+                raise GraphicException('Invalid bezier_precision value, must be >= 1')
+            self._bezier_precision = int(value)
+            self.flag_data_update()
+
+
+cdef class SmoothLine(Line):
+    '''Experimental line using over-draw methods to get better anti-aliasing
+    results. It has few drawbacks:
+
+    - drawing a line with alpha will probably not have the intended result if
+      the line crosses itself.
+    - :attr:`~Line.cap`, :attr:`~Line.joint` and :attr:`~Line.dash` properties
+      are not supported.
+    - it uses a custom texture with a premultiplied alpha.
+    - lines under 1px in width are not supported: they will look the same.
+
+    .. warning::
+
+        This is an unfinished work, experimental, and subject to crashes.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    cdef float _owidth
+
+    def __init__(self, **kwargs):
+        Line.__init__(self, **kwargs)
+        self._owidth = kwargs.get("overdraw_width") or <float>1.2
+        self.batch.set_mode("triangles")
+        self.texture = self.premultiplied_texture()
+
+    def premultiplied_texture(self):
+        texture = Texture.create(size=(4, 1), colorfmt="rgba")
+        texture.add_reload_observer(self._smooth_reload_observer)
+        self._smooth_reload_observer(texture)
+        return texture
+
+    cpdef _smooth_reload_observer(self, texture):
+        cdef bytes GRADIENT_DATA = (
+            b"\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00")
+        texture.blit_buffer(GRADIENT_DATA, colorfmt="rgba")
+
+    cdef void build(self):
+        if self._mode == LINE_MODE_ELLIPSE:
+            self.prebuild_ellipse()
+        elif self._mode == LINE_MODE_CIRCLE:
+            self.prebuild_circle()
+        elif self._mode == LINE_MODE_RECTANGLE:
+            self.prebuild_rectangle()
+        elif self._mode == LINE_MODE_ROUNDED_RECTANGLE:
+            self.prebuild_rounded_rectangle()
+        elif self._mode == LINE_MODE_BEZIER:
+            self.prebuild_bezier()
+
+        self.build_smooth()
+
+    cdef int apply(self) except -1:
+        VertexInstruction.apply(self)
+        return 0
+
+    cdef void build_smooth(self):
+        cdef:
+            list p = self.points
+            double width = max(0, (self._width - 1.))
+            double owidth = width + self._owidth
+            vertex_t *vertices = NULL
+            unsigned short *indices = NULL
+            unsigned short *tindices = NULL
+            double ax, ay, bx = 0., by = 0., rx = 0., ry = 0., last_angle = 0., angle, av_angle
+            double cos1, sin1, cos2, sin2, ocos1, ocos2, osin1, osin2
+            long index, icount, iv, ii, max_vindex, count
+            unsigned short i0, i1, i2, i3, i4, i5, i6, i7, vindex, vcount
+
+        iv = vindex = 0
+        count = <long>int(len(p) / 2.)
+        if count < 2:
+            self.batch.clear_data()
+            return
+
+        vcount = <unsigned short>(count * 4)
+        icount = (count - 1) * 18
+        if self._close:
+            icount += 18
+
+        vertices = <vertex_t *>malloc(vcount * sizeof(vertex_t))
+        if vertices == NULL:
+            raise MemoryError("vertices")
+
+        indices = <unsigned short *>malloc(icount * sizeof(unsigned short))
+        if indices == NULL:
+            free(vertices)
+            raise MemoryError("indices")
+
+        if self._close:
+            ax = p[-2]
+            ay = p[-1]
+            bx = p[0]
+            by = p[1]
+            rx = bx - ax
+            ry = by - ay
+            last_angle = atan2(ry, rx)
+
+        max_index = len(p)
+        for index in range(0, max_index, 2):
+            ax = p[index]
+            ay = p[index + 1]
+            if index < max_index - 2:
+                bx = p[index + 2]
+                by = p[index + 3]
+                rx = bx - ax
+                ry = by - ay
+                angle = atan2(ry, rx)
+            else:
+                angle = last_angle
+
+            if index == 0 and not self._close:
+                av_angle = angle
+                ad_angle = pi
+            else:
+                av_angle = atan2(
+                        sin(angle) + sin(last_angle),
+                        cos(angle) + cos(last_angle))
+
+                ad_angle = abs(pi - abs(angle - last_angle))
+
+            a1 = av_angle - PI2
+            a2 = av_angle + PI2
+            '''
+            cos1 = cos(a1) * width
+            sin1 = sin(a1) * width
+            cos2 = cos(a2) * width
+            sin2 = sin(a2) * width
+            ocos1 = cos(a1) * owidth
+            osin1 = sin(a1) * owidth
+            ocos2 = cos(a2) * owidth
+            osin2 = sin(a2) * owidth
+            print('angle diff', ad_angle)
+            '''
+            #l = width
+            #ol = owidth
+
+            if index == 0 or index >= max_index - 2:
+                l = width
+                ol = owidth
+            else:
+                la1 = last_angle - PI2
+                la2 = angle - PI2
+                ra1 = last_angle + PI2
+                ra2 = angle + PI2
+                ox = p[index - 2]
+                oy = p[index - 1]
+                if line_intersection(
+                    ox + cos(la1) * width,
+                    oy + sin(la1) * width,
+                    ax + cos(la1) * width,
+                    ay + sin(la1) * width,
+                    ax + cos(la2) * width,
+                    ay + sin(la2) * width,
+                    bx + cos(la2) * width,
+                    by + sin(la2) * width,
+                    &rx, &ry) == 0:
+                    # print('ERROR LINE INTERSECTION 1')
+                    pass
+
+                l = <float>sqrt((ax - rx) ** 2 + (ay - ry) ** 2)
+
+                if line_intersection(
+                    ox + cos(ra1) * owidth,
+                    oy + sin(ra1) * owidth,
+                    ax + cos(ra1) * owidth,
+                    ay + sin(ra1) * owidth,
+                    ax + cos(ra2) * owidth,
+                    ay + sin(ra2) * owidth,
+                    bx + cos(ra2) * owidth,
+                    by + sin(ra2) * owidth,
+                    &rx, &ry) == 0:
+                    # print('ERROR LINE INTERSECTION 2')
+                    pass
+
+                ol = <float>sqrt((ax - rx) ** 2 + (ay - ry) ** 2)
+
+            last_angle = angle
+
+            #l = sqrt(width ** 2 * (1. / sin(av_angle)) ** 2)
+            #l = width / tan(av_angle / 2.)
+            #l = width * sqrt(1 + 1 / (av_angle / 2.))
+            #l = 2 * (width * width * sin(av_angle))
+            #l = 2 * (cos(av_angle / 2.) * width)
+            #l = width / abs(cos(PI2 - 1.5 * ad_angle))
+            cos1 = cos(a1) * l
+            sin1 = sin(a1) * l
+            cos2 = cos(a2) * l
+            sin2 = sin(a2) * l
+
+            #ol = sqrt(owidth ** 2 * (1. / sin(av_angle)) ** 2)
+            #ol = owidth / tan(av_angle / 2.)
+            #ol = owidth * sqrt(1 + 1 / (av_angle / 2.))
+            #ol = 2 * (owidth * owidth * sin(av_angle))
+            #ol = 2 * (cos(av_angle / 2.) * owidth)
+            #ol = owidth / abs(cos(PI2 - 1.5 * ad_angle))
+            ocos1 = cos(a1) * ol
+            osin1 = sin(a1) * ol
+            ocos2 = cos(a2) * ol
+            osin2 = sin(a2) * ol
+
+            x1 = ax + cos1
+            y1 = ay + sin1
+            x2 = ax + cos2
+            y2 = ay + sin2
+
+            ox1 = ax + ocos1
+            oy1 = ay + osin1
+            ox2 = ax + ocos2
+            oy2 = ay + osin2
+
+            vertices[iv].x = <float>x1
+            vertices[iv].y = <float>y1
+            vertices[iv].s0 = 0.5
+            vertices[iv].t0 = 0.25
+            iv += 1
+            vertices[iv].x = <float>x2
+            vertices[iv].y = <float>y2
+            vertices[iv].s0 = 0.5
+            vertices[iv].t0 = 0.75
+            iv += 1
+            vertices[iv].x = <float>ox1
+            vertices[iv].y = <float>oy1
+            vertices[iv].s0 = 1
+            vertices[iv].t0 = 0
+            iv += 1
+            vertices[iv].x = <float>ox2
+            vertices[iv].y = <float>oy2
+            vertices[iv].s0 = 1
+            vertices[iv].t0 = 1
+            iv += 1
+
+        tindices = indices
+        for vindex in range(0, vcount - 4, 4):
+            tindices[0] = vindex
+            tindices[1] = vindex + 2
+            tindices[2] = vindex + 6
+            tindices[3] = vindex
+            tindices[4] = vindex + 6
+            tindices[5] = vindex + 4
+            tindices[6] = vindex + 1
+            tindices[7] = vindex
+            tindices[8] = vindex + 4
+            tindices[9] = vindex + 1
+            tindices[10] = vindex + 4
+            tindices[11] = vindex + 5
+            tindices[12] = vindex + 3
+            tindices[13] = vindex + 1
+            tindices[14] = vindex + 5
+            tindices[15] = vindex + 3
+            tindices[16] = vindex + 5
+            tindices[17] = vindex + 7
+            tindices = tindices + 18
+
+        if self._close:
+            vindex = vcount - 4
+            i0 = vindex
+            i1 = vindex + 1
+            i2 = vindex + 2
+            i3 = vindex + 3
+            i4 = 0
+            i5 = 1
+            i6 = 2
+            i7 = 3
+            tindices[0] = i0
+            tindices[1] = i2
+            tindices[2] = i6
+            tindices[3] = i0
+            tindices[4] = i6
+            tindices[5] = i4
+            tindices[6] = i1
+            tindices[7] = i0
+            tindices[8] = i4
+            tindices[9] = i1
+            tindices[10] = i4
+            tindices[11] = i5
+            tindices[12] = i3
+            tindices[13] = i1
+            tindices[14] = i5
+            tindices[15] = i3
+            tindices[16] = i5
+            tindices[17] = i7
+            tindices = tindices + 18
+
+        # print('tindices', <long>tindices, <long>indices, (<long>tindices - <long>indices) / sizeof(unsigned short))
+
+
+        self.batch.set_data(vertices, <int>vcount, indices, <int>icount)
+
+        free(vertices)
+        free(indices)
+
+
+    property overdraw_width:
+        '''Determine the overdraw width of the line, defaults to 1.2.
+        '''
+        def __get__(self):
+            return self._owidth
+
+        def __set__(self, value):
+            if value <= 0:
+                raise GraphicException('Invalid width value, must be > 0')
+            self._owidth = value
+            self.flag_data_update()
+
diff --git a/kivy/include/common_subset.h b/kivy/include/common_subset.h
new file mode 100644
index 0000000..0531180
--- /dev/null
+++ b/kivy/include/common_subset.h
@@ -0,0 +1,497 @@
+// GLES 2.0 Header file, generated for Kivy
+#pragma once
+#include "gl2platform.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Subset common to GLES and GL: ====================================
+typedef void             GLvoid;
+typedef char             GLchar;
+typedef unsigned int     GLenum;
+typedef unsigned char    GLboolean;
+typedef unsigned int     GLbitfield;
+typedef khronos_int8_t   GLbyte;
+typedef short            GLshort;
+typedef int              GLint;
+typedef int              GLsizei;
+typedef khronos_uint8_t  GLubyte;
+typedef unsigned short   GLushort;
+typedef unsigned int     GLuint;
+typedef khronos_float_t  GLfloat;
+typedef khronos_float_t  GLclampf;
+typedef GLclampf GLclampd;
+typedef khronos_intptr_t GLintptr;
+typedef khronos_ssize_t  GLsizeiptr;
+#define GL_DEPTH_BUFFER_BIT               0x00000100
+#define GL_STENCIL_BUFFER_BIT             0x00000400
+#define GL_COLOR_BUFFER_BIT               0x00004000
+#define GL_FALSE                          0
+#define GL_TRUE                           1
+#define GL_POINTS                         0x0000
+#define GL_LINES                          0x0001
+#define GL_LINE_LOOP                      0x0002
+#define GL_LINE_STRIP                     0x0003
+#define GL_TRIANGLES                      0x0004
+#define GL_TRIANGLE_STRIP                 0x0005
+#define GL_TRIANGLE_FAN                   0x0006
+#define GL_ZERO                           0
+#define GL_ONE                            1
+#define GL_SRC_COLOR                      0x0300
+#define GL_ONE_MINUS_SRC_COLOR            0x0301
+#define GL_SRC_ALPHA                      0x0302
+#define GL_ONE_MINUS_SRC_ALPHA            0x0303
+#define GL_DST_ALPHA                      0x0304
+#define GL_ONE_MINUS_DST_ALPHA            0x0305
+#define GL_DST_COLOR                      0x0306
+#define GL_ONE_MINUS_DST_COLOR            0x0307
+#define GL_SRC_ALPHA_SATURATE             0x0308
+#define GL_FUNC_ADD                       0x8006
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_BLEND_EQUATION_RGB             0x8009    /* same as BLEND_EQUATION */
+#define GL_BLEND_EQUATION_ALPHA           0x883D
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+#define GL_BLEND_DST_RGB                  0x80C8
+#define GL_BLEND_SRC_RGB                  0x80C9
+#define GL_BLEND_DST_ALPHA                0x80CA
+#define GL_BLEND_SRC_ALPHA                0x80CB
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+#define GL_ARRAY_BUFFER                   0x8892
+#define GL_ELEMENT_ARRAY_BUFFER           0x8893
+#define GL_ARRAY_BUFFER_BINDING           0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895
+#define GL_STREAM_DRAW                    0x88E0
+#define GL_STATIC_DRAW                    0x88E4
+#define GL_DYNAMIC_DRAW                   0x88E8
+#define GL_BUFFER_SIZE                    0x8764
+#define GL_BUFFER_USAGE                   0x8765
+#define GL_CURRENT_VERTEX_ATTRIB          0x8626
+#define GL_FRONT                          0x0404
+#define GL_BACK                           0x0405
+#define GL_FRONT_AND_BACK                 0x0408
+#define GL_TEXTURE_2D                     0x0DE1
+#define GL_CULL_FACE                      0x0B44
+#define GL_BLEND                          0x0BE2
+#define GL_DITHER                         0x0BD0
+#define GL_STENCIL_TEST                   0x0B90
+#define GL_DEPTH_TEST                     0x0B71
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_POLYGON_OFFSET_FILL            0x8037
+#define GL_SAMPLE_ALPHA_TO_COVERAGE       0x809E
+#define GL_SAMPLE_COVERAGE                0x80A0
+#define GL_NO_ERROR                       0
+#define GL_INVALID_ENUM                   0x0500
+#define GL_INVALID_VALUE                  0x0501
+#define GL_INVALID_OPERATION              0x0502
+#define GL_OUT_OF_MEMORY                  0x0505
+#define GL_CW                             0x0900
+#define GL_CCW                            0x0901
+#define GL_LINE_WIDTH                     0x0B21
+#define GL_ALIASED_POINT_SIZE_RANGE       0x846D
+#define GL_ALIASED_LINE_WIDTH_RANGE       0x846E
+#define GL_CULL_FACE_MODE                 0x0B45
+#define GL_FRONT_FACE                     0x0B46
+#define GL_DEPTH_RANGE                    0x0B70
+#define GL_DEPTH_WRITEMASK                0x0B72
+#define GL_DEPTH_CLEAR_VALUE              0x0B73
+#define GL_DEPTH_FUNC                     0x0B74
+#define GL_STENCIL_CLEAR_VALUE            0x0B91
+#define GL_STENCIL_FUNC                   0x0B92
+#define GL_STENCIL_FAIL                   0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL        0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS        0x0B96
+#define GL_STENCIL_REF                    0x0B97
+#define GL_STENCIL_VALUE_MASK             0x0B93
+#define GL_STENCIL_WRITEMASK              0x0B98
+#define GL_STENCIL_BACK_FUNC              0x8800
+#define GL_STENCIL_BACK_FAIL              0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL   0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS   0x8803
+#define GL_STENCIL_BACK_REF               0x8CA3
+#define GL_STENCIL_BACK_VALUE_MASK        0x8CA4
+#define GL_STENCIL_BACK_WRITEMASK         0x8CA5
+#define GL_VIEWPORT                       0x0BA2
+#define GL_SCISSOR_BOX                    0x0C10
+#define GL_COLOR_CLEAR_VALUE              0x0C22
+#define GL_COLOR_WRITEMASK                0x0C23
+#define GL_UNPACK_ALIGNMENT               0x0CF5
+#define GL_PACK_ALIGNMENT                 0x0D05
+#define GL_MAX_TEXTURE_SIZE               0x0D33
+#define GL_MAX_VIEWPORT_DIMS              0x0D3A
+#define GL_SUBPIXEL_BITS                  0x0D50
+#define GL_RED_BITS                       0x0D52
+#define GL_GREEN_BITS                     0x0D53
+#define GL_BLUE_BITS                      0x0D54
+#define GL_ALPHA_BITS                     0x0D55
+#define GL_DEPTH_BITS                     0x0D56
+#define GL_STENCIL_BITS                   0x0D57
+#define GL_POLYGON_OFFSET_UNITS           0x2A00
+#define GL_POLYGON_OFFSET_FACTOR          0x8038
+#define GL_TEXTURE_BINDING_2D             0x8069
+#define GL_SAMPLE_BUFFERS                 0x80A8
+#define GL_SAMPLES                        0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE          0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT         0x80AB
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS     0x86A3
+#define GL_DONT_CARE                      0x1100
+#define GL_FASTEST                        0x1101
+#define GL_NICEST                         0x1102
+#define GL_GENERATE_MIPMAP_HINT            0x8192
+#define GL_BYTE                           0x1400
+#define GL_UNSIGNED_BYTE                  0x1401
+#define GL_SHORT                          0x1402
+#define GL_UNSIGNED_SHORT                 0x1403
+#define GL_INT                            0x1404
+#define GL_UNSIGNED_INT                   0x1405
+#define GL_FLOAT                          0x1406
+#define GL_DEPTH_COMPONENT                0x1902
+#define GL_ALPHA                          0x1906
+#define GL_RGB                            0x1907
+#define GL_RGBA                           0x1908
+#define GL_LUMINANCE                      0x1909
+#define GL_LUMINANCE_ALPHA                0x190A
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_FRAGMENT_SHADER                  0x8B30
+#define GL_VERTEX_SHADER                    0x8B31
+#define GL_MAX_VERTEX_ATTRIBS               0x8869
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS   0x8B4C
+#define GL_MAX_TEXTURE_IMAGE_UNITS          0x8872
+#define GL_SHADER_TYPE                      0x8B4F
+#define GL_DELETE_STATUS                    0x8B80
+#define GL_LINK_STATUS                      0x8B82
+#define GL_VALIDATE_STATUS                  0x8B83
+#define GL_ATTACHED_SHADERS                 0x8B85
+#define GL_ACTIVE_UNIFORMS                  0x8B86
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH        0x8B87
+#define GL_ACTIVE_ATTRIBUTES                0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH      0x8B8A
+#define GL_SHADING_LANGUAGE_VERSION         0x8B8C
+#define GL_CURRENT_PROGRAM                  0x8B8D
+#define GL_NEVER                          0x0200
+#define GL_LESS                           0x0201
+#define GL_EQUAL                          0x0202
+#define GL_LEQUAL                         0x0203
+#define GL_GREATER                        0x0204
+#define GL_NOTEQUAL                       0x0205
+#define GL_GEQUAL                         0x0206
+#define GL_ALWAYS                         0x0207
+#define GL_KEEP                           0x1E00
+#define GL_REPLACE                        0x1E01
+#define GL_INCR                           0x1E02
+#define GL_DECR                           0x1E03
+#define GL_INVERT                         0x150A
+#define GL_INCR_WRAP                      0x8507
+#define GL_DECR_WRAP                      0x8508
+#define GL_VENDOR                         0x1F00
+#define GL_RENDERER                       0x1F01
+#define GL_VERSION                        0x1F02
+#define GL_EXTENSIONS                     0x1F03
+#define GL_NEAREST                        0x2600
+#define GL_LINEAR                         0x2601
+#define GL_NEAREST_MIPMAP_NEAREST         0x2700
+#define GL_LINEAR_MIPMAP_NEAREST          0x2701
+#define GL_NEAREST_MIPMAP_LINEAR          0x2702
+#define GL_LINEAR_MIPMAP_LINEAR           0x2703
+#define GL_TEXTURE_MAG_FILTER             0x2800
+#define GL_TEXTURE_MIN_FILTER             0x2801
+#define GL_TEXTURE_WRAP_S                 0x2802
+#define GL_TEXTURE_WRAP_T                 0x2803
+#define GL_TEXTURE                        0x1702
+#define GL_TEXTURE_CUBE_MAP               0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP       0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE      0x851C
+#define GL_TEXTURE0                       0x84C0
+#define GL_TEXTURE1                       0x84C1
+#define GL_TEXTURE2                       0x84C2
+#define GL_TEXTURE3                       0x84C3
+#define GL_TEXTURE4                       0x84C4
+#define GL_TEXTURE5                       0x84C5
+#define GL_TEXTURE6                       0x84C6
+#define GL_TEXTURE7                       0x84C7
+#define GL_TEXTURE8                       0x84C8
+#define GL_TEXTURE9                       0x84C9
+#define GL_TEXTURE10                      0x84CA
+#define GL_TEXTURE11                      0x84CB
+#define GL_TEXTURE12                      0x84CC
+#define GL_TEXTURE13                      0x84CD
+#define GL_TEXTURE14                      0x84CE
+#define GL_TEXTURE15                      0x84CF
+#define GL_TEXTURE16                      0x84D0
+#define GL_TEXTURE17                      0x84D1
+#define GL_TEXTURE18                      0x84D2
+#define GL_TEXTURE19                      0x84D3
+#define GL_TEXTURE20                      0x84D4
+#define GL_TEXTURE21                      0x84D5
+#define GL_TEXTURE22                      0x84D6
+#define GL_TEXTURE23                      0x84D7
+#define GL_TEXTURE24                      0x84D8
+#define GL_TEXTURE25                      0x84D9
+#define GL_TEXTURE26                      0x84DA
+#define GL_TEXTURE27                      0x84DB
+#define GL_TEXTURE28                      0x84DC
+#define GL_TEXTURE29                      0x84DD
+#define GL_TEXTURE30                      0x84DE
+#define GL_TEXTURE31                      0x84DF
+#define GL_ACTIVE_TEXTURE                 0x84E0
+#define GL_REPEAT                         0x2901
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_MIRRORED_REPEAT                0x8370
+#define GL_FLOAT_VEC2                     0x8B50
+#define GL_FLOAT_VEC3                     0x8B51
+#define GL_FLOAT_VEC4                     0x8B52
+#define GL_INT_VEC2                       0x8B53
+#define GL_INT_VEC3                       0x8B54
+#define GL_INT_VEC4                       0x8B55
+#define GL_BOOL                           0x8B56
+#define GL_BOOL_VEC2                      0x8B57
+#define GL_BOOL_VEC3                      0x8B58
+#define GL_BOOL_VEC4                      0x8B59
+#define GL_FLOAT_MAT2                     0x8B5A
+#define GL_FLOAT_MAT3                     0x8B5B
+#define GL_FLOAT_MAT4                     0x8B5C
+#define GL_SAMPLER_2D                     0x8B5E
+#define GL_SAMPLER_CUBE                   0x8B60
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED        0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE           0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE         0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE           0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED     0x886A
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER        0x8645
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_COMPILE_STATUS                 0x8B81
+#define GL_INFO_LOG_LENGTH                0x8B84
+#define GL_SHADER_SOURCE_LENGTH           0x8B88
+#define GL_RGBA4                          0x8056
+#define GL_RGB5_A1                        0x8057
+#define GL_DEPTH_COMPONENT16              0x81A5
+// not anymore in GLES 2.0?
+//#define GL_STENCIL_INDEX                  0x1901
+#define GL_NONE                           0
+GL_APICALL void         GL_APIENTRY glActiveTexture (GLenum texture);
+GL_APICALL void         GL_APIENTRY glAttachShader (GLuint program, GLuint shader);
+GL_APICALL void         GL_APIENTRY glBindAttribLocation (GLuint program, GLuint index, const GLchar* name);
+GL_APICALL void         GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer);
+GL_APICALL void         GL_APIENTRY glBindTexture (GLenum target, GLuint texture);
+GL_APICALL void         GL_APIENTRY glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+GL_APICALL void         GL_APIENTRY glBlendEquation ( GLenum mode );
+GL_APICALL void         GL_APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
+GL_APICALL void         GL_APIENTRY glBlendFuncSeparate (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+GL_APICALL void         GL_APIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
+GL_APICALL void         GL_APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
+GL_APICALL void         GL_APIENTRY glClear (GLbitfield mask);
+GL_APICALL void         GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+#ifdef __arm
+GL_APICALL void         GL_APIENTRY glClearDepthf (GLclampf depth);
+#else
+// Different Name; Redefine
+extern void glClearDepth (GLclampd depth);
+#define glClearDepthf glClearDepth
+#endif
+GL_APICALL void         GL_APIENTRY glClearStencil (GLint s);
+GL_APICALL void         GL_APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+GL_APICALL void         GL_APIENTRY glCompileShader (GLuint shader);
+GL_APICALL void         GL_APIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);
+GL_APICALL void         GL_APIENTRY glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);
+GL_APICALL void         GL_APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GL_APICALL void         GL_APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GL_APICALL GLuint       GL_APIENTRY glCreateProgram (void);
+GL_APICALL GLuint       GL_APIENTRY glCreateShader (GLenum type);
+GL_APICALL void         GL_APIENTRY glCullFace (GLenum mode);
+GL_APICALL void         GL_APIENTRY glDeleteBuffers (GLsizei n, const GLuint* buffers);
+GL_APICALL void         GL_APIENTRY glDeleteProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glDeleteShader (GLuint shader);
+GL_APICALL void         GL_APIENTRY glDeleteTextures (GLsizei n, const GLuint* textures);
+GL_APICALL void         GL_APIENTRY glDepthFunc (GLenum func);
+GL_APICALL void         GL_APIENTRY glDepthMask (GLboolean flag);
+#ifdef __arm
+GL_APICALL void         GL_APIENTRY glDepthRangef (GLclampf zNear, GLclampf zFar);
+#else
+// Different Name; Redefine
+extern void glDepthRange (GLclampd zNear, GLclampd zFar);
+#define glDepthRangef glDepthRange
+#endif
+GL_APICALL void         GL_APIENTRY glDetachShader (GLuint program, GLuint shader);
+GL_APICALL void         GL_APIENTRY glDisable (GLenum cap);
+GL_APICALL void         GL_APIENTRY glDisableVertexAttribArray (GLuint index);
+GL_APICALL void         GL_APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
+GL_APICALL void         GL_APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
+GL_APICALL void         GL_APIENTRY glEnable (GLenum cap);
+GL_APICALL void         GL_APIENTRY glEnableVertexAttribArray (GLuint index);
+GL_APICALL void         GL_APIENTRY glFinish (void);
+GL_APICALL void         GL_APIENTRY glFlush (void);
+GL_APICALL void         GL_APIENTRY glFrontFace (GLenum mode);
+GL_APICALL void         GL_APIENTRY glGenBuffers (GLsizei n, GLuint* buffers);
+GL_APICALL void         GL_APIENTRY glGenTextures (GLsizei n, GLuint* textures);
+GL_APICALL void         GL_APIENTRY glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetActiveUniform (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetAttachedShaders (GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
+GL_APICALL int          GL_APIENTRY glGetAttribLocation (GLuint program, const GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetBooleanv (GLenum pname, GLboolean* params);
+GL_APICALL void         GL_APIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint* params);
+GL_APICALL GLenum       GL_APIENTRY glGetError (void);
+GL_APICALL void         GL_APIENTRY glGetFloatv (GLenum pname, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetIntegerv (GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);
+GL_APICALL void         GL_APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog);
+GL_APICALL void         GL_APIENTRY glGetShaderSource (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
+GL_APICALL const GLubyte* GL_APIENTRY glGetString (GLenum name);
+GL_APICALL void         GL_APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetUniformfv (GLuint program, GLint location, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetUniformiv (GLuint program, GLint location, GLint* params);
+GL_APICALL int          GL_APIENTRY glGetUniformLocation (GLuint program, const GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid** pointer);
+GL_APICALL void         GL_APIENTRY glHint (GLenum target, GLenum mode);
+GL_APICALL GLboolean    GL_APIENTRY glIsBuffer (GLuint buffer);
+GL_APICALL GLboolean    GL_APIENTRY glIsEnabled (GLenum cap);
+GL_APICALL GLboolean    GL_APIENTRY glIsProgram (GLuint program);
+GL_APICALL GLboolean    GL_APIENTRY glIsShader (GLuint shader);
+GL_APICALL GLboolean    GL_APIENTRY glIsTexture (GLuint texture);
+GL_APICALL void         GL_APIENTRY glLineWidth (GLfloat width);
+GL_APICALL void         GL_APIENTRY glLinkProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glPixelStorei (GLenum pname, GLint param);
+GL_APICALL void         GL_APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
+GL_APICALL void         GL_APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
+GL_APICALL void         GL_APIENTRY glSampleCoverage (GLclampf value, GLboolean invert);
+GL_APICALL void         GL_APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+GL_APICALL void         GL_APIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar** string, const GLint* length);
+GL_APICALL void         GL_APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilMask (GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilMaskSeparate (GLenum face, GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
+GL_APICALL void         GL_APIENTRY glStencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
+GL_APICALL void         GL_APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
+GL_APICALL void         GL_APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
+GL_APICALL void         GL_APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat* params);
+GL_APICALL void         GL_APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+GL_APICALL void         GL_APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint* params);
+GL_APICALL void         GL_APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
+GL_APICALL void         GL_APIENTRY glUniform1f (GLint location, GLfloat x);
+GL_APICALL void         GL_APIENTRY glUniform1fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform1i (GLint location, GLint x);
+GL_APICALL void         GL_APIENTRY glUniform1iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniform2f (GLint location, GLfloat x, GLfloat y);
+GL_APICALL void         GL_APIENTRY glUniform2fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform2i (GLint location, GLint x, GLint y);
+GL_APICALL void         GL_APIENTRY glUniform2iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniform3f (GLint location, GLfloat x, GLfloat y, GLfloat z);
+GL_APICALL void         GL_APIENTRY glUniform3fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform3i (GLint location, GLint x, GLint y, GLint z);
+GL_APICALL void         GL_APIENTRY glUniform3iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniform4f (GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GL_APICALL void         GL_APIENTRY glUniform4fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform4i (GLint location, GLint x, GLint y, GLint z, GLint w);
+GL_APICALL void         GL_APIENTRY glUniform4iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void         GL_APIENTRY glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void         GL_APIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void         GL_APIENTRY glUseProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glValidateProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glVertexAttrib1f (GLuint indx, GLfloat x);
+GL_APICALL void         GL_APIENTRY glVertexAttrib1fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttrib2f (GLuint indx, GLfloat x, GLfloat y);
+GL_APICALL void         GL_APIENTRY glVertexAttrib2fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttrib3f (GLuint indx, GLfloat x, GLfloat y, GLfloat z);
+GL_APICALL void         GL_APIENTRY glVertexAttrib3fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttrib4f (GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GL_APICALL void         GL_APIENTRY glVertexAttrib4fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttribPointer (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr);
+GL_APICALL void         GL_APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+
+// Subset common to GLES and GLEXT: =================================
+#define GL_FIXED                          0x140C
+#define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
+#define GL_MAX_VARYING_VECTORS              0x8DFC
+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE   0x8B9A
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
+#define GL_SHADER_COMPILER                0x8DFA
+#define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
+#define GL_LOW_FLOAT                      0x8DF0
+#define GL_MEDIUM_FLOAT                   0x8DF1
+#define GL_HIGH_FLOAT                     0x8DF2
+#define GL_LOW_INT                        0x8DF3
+#define GL_MEDIUM_INT                     0x8DF4
+#define GL_HIGH_INT                       0x8DF5
+#define GL_FRAMEBUFFER                    0x8D40
+#define GL_RENDERBUFFER                   0x8D41
+#define GL_STENCIL_INDEX8                 0x8D48
+#define GL_DEPTH24_STENCIL8_OES           0x88F0
+#define GL_RENDERBUFFER_WIDTH             0x8D42
+#define GL_RENDERBUFFER_HEIGHT            0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT   0x8D44
+#define GL_RENDERBUFFER_RED_SIZE          0x8D50
+#define GL_RENDERBUFFER_GREEN_SIZE        0x8D51
+#define GL_RENDERBUFFER_BLUE_SIZE         0x8D52
+#define GL_RENDERBUFFER_ALPHA_SIZE        0x8D53
+#define GL_RENDERBUFFER_DEPTH_SIZE        0x8D54
+#define GL_RENDERBUFFER_STENCIL_SIZE      0x8D55
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         0x8CD2
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_COLOR_ATTACHMENT0              0x8CE0
+#define GL_DEPTH_ATTACHMENT               0x8D00
+#define GL_STENCIL_ATTACHMENT             0x8D20
+#define GL_FRAMEBUFFER_COMPLETE                      0x8CD5
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT         0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+// Different Name; Redefine
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9
+#ifndef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
+#endif
+#define GL_FRAMEBUFFER_UNSUPPORTED                   0x8CDD
+#define GL_FRAMEBUFFER_BINDING            0x8CA6
+#define GL_RENDERBUFFER_BINDING           0x8CA7
+#define GL_MAX_RENDERBUFFER_SIZE          0x84E8
+#define GL_INVALID_FRAMEBUFFER_OPERATION  0x0506
+GL_APICALL void         GL_APIENTRY glBindFramebuffer (GLenum target, GLuint framebuffer);
+GL_APICALL void         GL_APIENTRY glBindRenderbuffer (GLenum target, GLuint renderbuffer);
+GL_APICALL void         GL_APIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
+GL_APICALL GLenum       GL_APIENTRY glCheckFramebufferStatus (GLenum target);
+GL_APICALL void         GL_APIENTRY glDeleteFramebuffers (GLsizei n, const GLuint* framebuffers);
+GL_APICALL void         GL_APIENTRY glDeleteRenderbuffers (GLsizei n, const GLuint* renderbuffers);
+GL_APICALL void         GL_APIENTRY glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+GL_APICALL void         GL_APIENTRY glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GL_APICALL void         GL_APIENTRY glGenerateMipmap (GLenum target);
+GL_APICALL void         GL_APIENTRY glGenFramebuffers (GLsizei n, GLuint* framebuffers);
+GL_APICALL void         GL_APIENTRY glGenRenderbuffers (GLsizei n, GLuint* renderbuffers);
+GL_APICALL void         GL_APIENTRY glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params);
+//GL_APICALL void         GL_APIENTRY glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
+GL_APICALL GLboolean    GL_APIENTRY glIsFramebuffer (GLuint framebuffer);
+GL_APICALL GLboolean    GL_APIENTRY glIsRenderbuffer (GLuint renderbuffer);
+GL_APICALL void         GL_APIENTRY glReleaseShaderCompiler (void);
+GL_APICALL void         GL_APIENTRY glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+//GL_APICALL void         GL_APIENTRY glShaderBinary (GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);
+
+// What follows was manually extracted from the GLES2 headers because
+// it was not present in any other header.
+#define GL_SHADER_BINARY_FORMATS          0x8DF8
+#define GL_RGB565                         0x8D62
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/kivy/include/config.h b/kivy/include/config.h
new file mode 100644
index 0000000..e5d3bda
--- /dev/null
+++ b/kivy/include/config.h
@@ -0,0 +1,18 @@
+// Autogenerated file for Kivy C configuration
+#define __PY3 1
+#define __USE_RPI 0
+#define __USE_EGL 0
+#define __USE_OPENGL_ES2 0
+#define __USE_OPENGL_MOCK 0
+#define __USE_SDL2 1
+#define __USE_PANGOFT2 0
+#define __USE_IOS 0
+#define __USE_ANDROID 0
+#define __USE_MESAGL 0
+#define __USE_X11 1
+#define __USE_WAYLAND 0
+#define __USE_GSTREAMER 0
+#define __USE_AVFOUNDATION 0
+#define __USE_OSX_FRAMEWORKS 0
+#define __DEBUG_GL 0
+#define __KIVY_SDL_GL_ALPHA_SIZE 8
diff --git a/kivy/include/config.pxi b/kivy/include/config.pxi
new file mode 100644
index 0000000..137c4cd
--- /dev/null
+++ b/kivy/include/config.pxi
@@ -0,0 +1,20 @@
+# Autogenerated file for Kivy Cython configuration
+DEF PY3 = 1
+DEF USE_RPI = 0
+DEF USE_EGL = 0
+DEF USE_OPENGL_ES2 = 0
+DEF USE_OPENGL_MOCK = 0
+DEF USE_SDL2 = 1
+DEF USE_PANGOFT2 = 0
+DEF USE_IOS = 0
+DEF USE_ANDROID = 0
+DEF USE_MESAGL = 0
+DEF USE_X11 = 1
+DEF USE_WAYLAND = 0
+DEF USE_GSTREAMER = 0
+DEF USE_AVFOUNDATION = 0
+DEF USE_OSX_FRAMEWORKS = 0
+DEF DEBUG_GL = 0
+DEF KIVY_SDL_GL_ALPHA_SIZE = 8
+DEF DEBUG = False
+DEF PLATFORM = "linux"
diff --git a/kivy/include/gl2platform.h b/kivy/include/gl2platform.h
new file mode 100644
index 0000000..91f91a1
--- /dev/null
+++ b/kivy/include/gl2platform.h
@@ -0,0 +1,30 @@
+#ifndef __gl2platform_h_
+#define __gl2platform_h_
+
+/* $Revision: 10602 $ on $Date:: 2010-03-04 22:35:34 -0800 #$ */
+
+/*
+ * This document is licensed under the SGI Free Software B License Version
+ * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ .
+ */
+
+/* Platform-specific types and definitions for OpenGL ES 2.X  gl2.h
+ *
+ * Adopters may modify khrplatform.h and this file to suit their platform.
+ * You are encouraged to submit all modifications to the Khronos group so that
+ * they can be included in future versions of this file.  Please submit changes
+ * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
+ * by filing a bug against product "OpenGL-ES" component "Registry".
+ */
+
+#include "khrplatform.h"
+
+#ifndef GL_APICALL
+#define GL_APICALL  KHRONOS_APICALL
+#endif
+
+#ifndef GL_APIENTRY
+#define GL_APIENTRY KHRONOS_APIENTRY
+#endif
+
+#endif /* __gl2platform_h_ */
diff --git a/kivy/include/gl_redirect.h b/kivy/include/gl_redirect.h
new file mode 100644
index 0000000..0a45f04
--- /dev/null
+++ b/kivy/include/gl_redirect.h
@@ -0,0 +1,104 @@
+/**
+ * Includes GL headers.
+ */
+#ifndef __gl_redirect_h_
+#define __gl_redirect_h_
+
+#include "config.h"
+
+#if defined(_WIN32)
+    #include <windows.h>
+    #include <string.h>
+#endif /* _WIN32 */
+
+#define GL_FIXED                                    0x140C
+#define GL_MAX_VERTEX_UNIFORM_VECTORS               0x8DFB
+#define GL_MAX_VARYING_VECTORS                      0x8DFC
+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS             0x8DFD
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE           0x8B9A
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT         0x8B9B
+#define GL_SHADER_COMPILER                          0x8DFA
+#define GL_NUM_SHADER_BINARY_FORMATS                0x8DF9
+#define GL_LOW_FLOAT                                0x8DF0
+#define GL_MEDIUM_FLOAT                             0x8DF1
+#define GL_HIGH_FLOAT                               0x8DF2
+#define GL_LOW_INT                                  0x8DF3
+#define GL_MEDIUM_INT                               0x8DF4
+#define GL_HIGH_INT                                 0x8DF5
+#define GL_SHADER_BINARY_FORMATS                    0x8DF8
+#define GL_RGB565                                   0x8D62
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS        0x8CD9
+#define GL_FRAMEBUFFER_UNDEFINED_OES                0x8219
+#define GL_DEPTH24_STENCIL8_OES                     0x88F0
+
+#if __USE_OPENGL_MOCK
+    #include "common_subset.h"
+#elif defined(_WIN32)
+    #include <GL/glew.h>
+    #define GL_GLEXT_PROTOTYPES
+    #define GL_APICALL
+    #define GL_APIENTRY
+    #ifndef GL_EXT_blend_func_extended
+    #define GL_EXT_blend_func_extended
+    #endif
+    #define GL_EXT_disjoint_timer_query
+    #ifndef GL_EXT_geometry_shader
+    #define GL_EXT_geometry_shader
+    #endif
+    #ifndef GL_EXT_multisampled_render_to_texture
+    #define GL_EXT_multisampled_render_to_texture
+    #endif
+    #define GL_EXT_texture_border_clamp
+    #define GL_EXT_texture_buffer
+    #ifndef GL_EXT_texture_storage
+    #define GL_EXT_texture_storage
+    #endif
+
+#else
+
+#	if __USE_OPENGL_ES2
+#		if __APPLE__
+#			include "common_subset.h"
+#		else
+#			include <GLES2/gl2.h>
+#			include <GLES2/gl2ext.h>
+#		endif
+#	else
+#		ifdef __APPLE__
+#			include <OpenGL/gl.h>
+#			include <OpenGL/glext.h>
+#		else
+#			define GL_GLEXT_PROTOTYPES
+#			include <GL/gl.h>
+#			include <GL/glext.h>
+#		endif
+#		define GL_SHADER_BINARY_FORMATS					0x8DF8
+#		define GL_RGB565								0x8D62
+#		define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 	0x8CD9
+#   endif
+
+
+
+#   ifndef GL_DEPTH24_STENCIL8
+#       define GL_DEPTH24_STENCIL8                      GL_DEPTH24_STENCIL8_OES
+#   endif
+
+#endif /* defined(_WIN32) */
+
+// In the webserver / unittest / buildbot case, we are compiling and running
+// kivy in an headless env, without proper GL support.
+// This is a hack to prevent to link with wrong symbol. :(
+#if __USE_MESAGL == 1
+#	define glBlendEquationSeparate(x, y)
+#	define glDepthRangef glDepthRange
+#	define glClearDepthf glClearDepth
+
+// C redirection to prevent warning of undeclared symbol
+// (these functions are not existing in GLES2, but if we are using GLES2
+// headers with GL library, we need to declare them.)
+GL_APICALL void GL_APIENTRY glDepthRange( GLclampf near_val, GLclampf far_val );
+GL_APICALL void GL_APIENTRY glClearDepth( GLclampf depth );
+
+#endif
+
+#endif /* __gl_redirect_h_ */
diff --git a/kivy/include/khrplatform.h b/kivy/include/khrplatform.h
new file mode 100644
index 0000000..8ec0d19
--- /dev/null
+++ b/kivy/include/khrplatform.h
@@ -0,0 +1,269 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2009 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * $Revision: 9356 $ on $Date: 2009-10-21 02:52:25 -0700 (Wed, 21 Oct 2009) $
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by sending them to the public Khronos Bugzilla
+ * (http://khronos.org/bugzilla) by filing a bug against product
+ * "Khronos (general)" component "Registry".
+ *
+ * A predefined template which fills in some of the bug fields can be
+ * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
+ * must create a Bugzilla login first.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */
diff --git a/kivy/input/__init__.py b/kivy/input/__init__.py
new file mode 100644
index 0000000..45cc95f
--- /dev/null
+++ b/kivy/input/__init__.py
@@ -0,0 +1,39 @@
+# pylint: disable=W0611
+'''
+Input management
+================
+
+Our input system is wide and simple at the same time. We are currently able to
+natively support :
+
+* Windows multitouch events (pencil and finger)
+* OS X touchpads
+* Linux multitouch events (kernel and mtdev)
+* Linux wacom drivers (pencil and finger)
+* TUIO
+
+All the input management is configurable in the Kivy :mod:`~kivy.config`. You
+can easily use many multitouch devices in one Kivy application.
+
+When the events have been read from the devices, they are dispatched through
+a post processing module before being sent to your application. We also have
+several default modules for :
+
+* Double tap detection
+* Decreasing jittering
+* Decreasing the inaccuracy of touch on "bad" DIY hardware
+* Ignoring regions
+'''
+
+
+from kivy.input.motionevent import MotionEvent
+from kivy.input.postproc import kivy_postproc_modules
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+import kivy.input.providers
+
+__all__ = (
+    MotionEvent.__name__,
+    MotionEventProvider.__name__,
+    MotionEventFactory.__name__,
+    'kivy_postproc_modules')
diff --git a/kivy/input/__pycache__/__init__.cpython-310.pyc b/kivy/input/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..695538b
Binary files /dev/null and b/kivy/input/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/input/__pycache__/factory.cpython-310.pyc b/kivy/input/__pycache__/factory.cpython-310.pyc
new file mode 100644
index 0000000..7ee0a25
Binary files /dev/null and b/kivy/input/__pycache__/factory.cpython-310.pyc differ
diff --git a/kivy/input/__pycache__/motionevent.cpython-310.pyc b/kivy/input/__pycache__/motionevent.cpython-310.pyc
new file mode 100644
index 0000000..4df7eb1
Binary files /dev/null and b/kivy/input/__pycache__/motionevent.cpython-310.pyc differ
diff --git a/kivy/input/__pycache__/provider.cpython-310.pyc b/kivy/input/__pycache__/provider.cpython-310.pyc
new file mode 100644
index 0000000..3a1cbe0
Binary files /dev/null and b/kivy/input/__pycache__/provider.cpython-310.pyc differ
diff --git a/kivy/input/__pycache__/recorder.cpython-310.pyc b/kivy/input/__pycache__/recorder.cpython-310.pyc
new file mode 100644
index 0000000..8cba8ae
Binary files /dev/null and b/kivy/input/__pycache__/recorder.cpython-310.pyc differ
diff --git a/kivy/input/__pycache__/shape.cpython-310.pyc b/kivy/input/__pycache__/shape.cpython-310.pyc
new file mode 100644
index 0000000..760ddf9
Binary files /dev/null and b/kivy/input/__pycache__/shape.cpython-310.pyc differ
diff --git a/kivy/input/factory.py b/kivy/input/factory.py
new file mode 100644
index 0000000..244cf9e
--- /dev/null
+++ b/kivy/input/factory.py
@@ -0,0 +1,35 @@
+'''
+Motion Event Factory
+====================
+
+Factory of :class:`~kivy.input.motionevent.MotionEvent` providers.
+'''
+
+__all__ = ('MotionEventFactory', )
+
+
+class MotionEventFactory:
+    '''MotionEvent factory is a class that registers all availables input
+    factories. If you create a new input factory, you need to register
+    it here::
+
+        MotionEventFactory.register('myproviderid', MyInputProvider)
+
+    '''
+    __providers__ = {}
+
+    @staticmethod
+    def register(name, classname):
+        '''Register a input provider in the database'''
+        MotionEventFactory.__providers__[name] = classname
+
+    @staticmethod
+    def list():
+        '''Get a list of all available providers'''
+        return MotionEventFactory.__providers__
+
+    @staticmethod
+    def get(name):
+        '''Get a provider class from the provider id'''
+        if name in MotionEventFactory.__providers__:
+            return MotionEventFactory.__providers__[name]
diff --git a/kivy/input/motionevent.py b/kivy/input/motionevent.py
new file mode 100644
index 0000000..e949793
--- /dev/null
+++ b/kivy/input/motionevent.py
@@ -0,0 +1,587 @@
+'''
+.. _motionevent:
+
+Motion Event
+============
+
+The :class:`MotionEvent` is the base class used for events provided by
+pointing devices (touch and non-touch). This class defines all the properties
+and methods needed to handle 2D and 3D movements but has many more
+capabilities.
+
+Usually you would never need to create the :class:`MotionEvent` yourself as
+this is the role of the :mod:`~kivy.input.providers`.
+
+Flow of the motion events
+-------------------------
+
+1. The :class:`MotionEvent` 's are gathered from input providers by
+   :class:`~kivy.base.EventLoopBase`.
+2. Post processing is performed by registered processors
+   :mod:`~kivy.input.postproc`.
+3. :class:`~kivy.base.EventLoopBase` dispatches all motion events using
+   `on_motion` event to all registered listeners including the
+   :class:`~kivy.core.window.WindowBase`.
+4. Once received in :meth:`~kivy.core.window.WindowBase.on_motion` events
+   (touch or non-touch) are all registered managers. If a touch event is not
+   handled by at least one manager, then it is dispatched through
+   :meth:`~kivy.core.window.WindowBase.on_touch_down`,
+   :meth:`~kivy.core.window.WindowBase.on_touch_move` and
+   :meth:`~kivy.core.window.WindowBase.on_touch_up`.
+5. Widgets receive events in :meth:`~kivy.uix.widget.Widget.on_motion` method
+   (if passed by a manager) or on `on_touch_xxx` methods.
+
+Motion events and event managers
+--------------------------------
+
+A motion event is a touch event if its :attr:`MotionEvent.is_touch` is set to
+`True`. Beside `is_touch` attribute, :attr:`MotionEvent.type_id` can be used to
+check for event's general type. Currently two types are dispatched by
+input providers: "touch" and "hover".
+
+Event managers can be used to dispatch any motion event throughout the widget
+tree and a manager uses `type_id` to specify which event types it want to
+receive. See :mod:`~kivy.eventmanager` to learn how to define and register
+an event manager.
+
+A manager can also assign a new `type_id` to
+:attr:`MotionEvent.type_id` before dispatching it to the widgets. This useful
+when dispatching a specific event::
+
+    class MouseTouchManager(EventManagerBase):
+
+        type_ids = ('touch',)
+
+        def dispatch(self, etype, me):
+            accepted = False
+            if me.device == 'mouse':
+                me.push() # Save current type_id and other values
+                me.type_id = 'mouse_touch'
+                self.window.transform_motion_event_2d(me)
+                # Dispatch mouse touch event to widgets which registered
+                # to receive 'mouse_touch'
+                for widget in self.window.children[:]:
+                    if widget.dispatch('on_motion', etype, me):
+                        accepted = True
+                        break
+                me.pop() # Restore
+            return accepted
+
+Listening to a motion event
+---------------------------
+
+If you want to receive all motion events, touch or not, you can bind the
+MotionEvent from the :class:`~kivy.core.window.Window` to your own callback::
+
+    def on_motion(self, etype, me):
+        # will receive all motion events.
+        pass
+
+    Window.bind(on_motion=on_motion)
+
+You can also listen to changes of the mouse position by watching
+:attr:`~kivy.core.window.WindowBase.mouse_pos`.
+
+Profiles
+--------
+
+The :class:`MotionEvent` stores device specific information in various
+properties listed in the :attr:`~MotionEvent.profile`.
+For example, you can receive a MotionEvent that has an angle, a fiducial
+ID, or even a shape. You can check the :attr:`~MotionEvent.profile`
+attribute to see what is currently supported by the MotionEvent provider.
+
+This is a short list of the profile values supported by default. Please check
+the :attr:`MotionEvent.profile` property to see what profile values are
+available.
+
+============== ================================================================
+Profile value   Description
+-------------- ----------------------------------------------------------------
+angle          2D angle. Accessed via the `a` property.
+button         Mouse button ('left', 'right', 'middle', 'scrollup' or
+               'scrolldown'). Accessed via the `button` property.
+markerid       Marker or Fiducial ID. Accessed via the `fid` property.
+pos            2D position. Accessed via the `x`, `y` or `pos` properties.
+pos3d          3D position. Accessed via the `x`, `y` or `z` properties.
+pressure       Pressure of the contact. Accessed via the `pressure` property.
+shape          Contact shape. Accessed via the `shape` property .
+============== ================================================================
+
+If you want to know whether the current :class:`MotionEvent` has an angle::
+
+    def on_touch_move(self, touch):
+        if 'angle' in touch.profile:
+            print('The touch angle is', touch.a)
+
+If you want to select only the fiducials::
+
+    def on_touch_move(self, touch):
+        if 'markerid' not in touch.profile:
+            return
+
+'''
+
+__all__ = ('MotionEvent', )
+
+import weakref
+from inspect import isroutine
+from copy import copy
+from time import time
+
+from kivy.eventmanager import MODE_DEFAULT_DISPATCH
+from kivy.vector import Vector
+
+
+class EnhancedDictionary(dict):
+
+    def __getattr__(self, attr):
+        try:
+            return self.__getitem__(attr)
+        except KeyError:
+            return super(EnhancedDictionary, self).__getattr__(attr)
+
+    def __setattr__(self, attr, value):
+        self.__setitem__(attr, value)
+
+
+class MotionEventMetaclass(type):
+
+    def __new__(mcs, name, bases, attrs):
+        __attrs__ = []
+        for base in bases:
+            if hasattr(base, '__attrs__'):
+                __attrs__.extend(base.__attrs__)
+        if '__attrs__' in attrs:
+            __attrs__.extend(attrs['__attrs__'])
+        attrs['__attrs__'] = tuple(__attrs__)
+        return super(MotionEventMetaclass, mcs).__new__(mcs, name,
+                                                        bases, attrs)
+
+
+MotionEventBase = MotionEventMetaclass('MotionEvent', (object, ), {})
+
+
+class MotionEvent(MotionEventBase):
+    '''Abstract class that represents an input event.
+
+    :Parameters:
+        `id`: str
+            unique ID of the MotionEvent
+        `args`: list
+            list of parameters, passed to the depack() function
+    '''
+
+    __uniq_id = 0
+    __attrs__ = \
+        ('device', 'push_attrs', 'push_attrs_stack',
+         'is_touch', 'type_id', 'id', 'dispatch_mode', 'shape', 'profile',
+         # current position, in 0-1 range
+         'sx', 'sy', 'sz',
+         # first position set, in 0-1 range
+         'osx', 'osy', 'osz',
+         # last position set, in 0-1 range
+         'psx', 'psy', 'psz',
+         # delta from the last position and current one, in 0-1 range
+         'dsx', 'dsy', 'dsz',
+         # current position, in screen range
+         'x', 'y', 'z',
+         # first position set, in screen range
+         'ox', 'oy', 'oz',
+         # last position set, in 0-1 range
+         'px', 'py', 'pz',
+         # delta from the last position and current one, in screen range
+         'dx', 'dy', 'dz',
+         'time_start',
+         'is_double_tap', 'double_tap_time',
+         'is_triple_tap', 'triple_tap_time',
+         'ud')
+
+    def __init__(self, device, id, args, is_touch=False, type_id=None):
+        if self.__class__ == MotionEvent:
+            raise NotImplementedError('class MotionEvent is abstract')
+        MotionEvent.__uniq_id += 1
+
+        #: True if the MotionEvent is a touch.
+        self.is_touch = is_touch
+
+        #: (Experimental) String to identify event type.
+        #:
+        #: .. versionadded:: 2.1.0
+        self.type_id = type_id
+
+        #: (Experimental) Used by a event manager or a widget to assign
+        #: the dispatching mode. Defaults to
+        #: :const:`~kivy.eventmanager.MODE_DEFAULT_DISPATCH`. See
+        #: :mod:`~kivy.eventmanager` for available modes.
+        #:
+        #: .. versionadded:: 2.1.0
+        self.dispatch_mode = MODE_DEFAULT_DISPATCH
+
+        #: Attributes to push by default, when we use :meth:`push` : x, y, z,
+        #: dx, dy, dz, ox, oy, oz, px, py, pz.
+        self.push_attrs_stack = []
+        self.push_attrs = ('x', 'y', 'z', 'dx', 'dy', 'dz', 'ox', 'oy', 'oz',
+                           'px', 'py', 'pz', 'pos', 'type_id', 'dispatch_mode')
+
+        #: Uniq ID of the event. You can safely use this property, it will be
+        #: never the same across all existing events.
+        self.uid = MotionEvent.__uniq_id
+
+        #: Device used for creating this event.
+        self.device = device
+
+        # For grab
+        self.grab_list = []
+        self.grab_exclusive_class = None
+        self.grab_state = False
+
+        #: Used to determine which widget the event is being dispatched to.
+        #: Check the :meth:`grab` function for more information.
+        self.grab_current = None
+
+        #: Currently pressed button.
+        self.button = None
+
+        #: Profiles currently used in the event.
+        self.profile = []
+
+        #: Id of the event, not unique. This is generally the Id set by the
+        #: input provider, like ID in TUIO. If you have multiple TUIO sources,
+        #: then same id can be used. Prefer to use :attr:`uid` attribute
+        #: instead.
+        self.id = id
+
+        #: Shape of the touch event, subclass of
+        #: :class:`~kivy.input.shape.Shape`.
+        #: By default, the property is set to None.
+        self.shape = None
+
+        #: X position, in 0-1 range.
+        self.sx = 0.0
+        #: Y position, in 0-1 range.
+        self.sy = 0.0
+        #: Z position, in 0-1 range.
+        self.sz = 0.0
+        #: Origin X position, in 0-1 range.
+        self.osx = None
+        #: Origin Y position, in 0-1 range.
+        self.osy = None
+        #: Origin Z position, in 0-1 range.
+        self.osz = None
+        #: Previous X position, in 0-1 range.
+        self.psx = None
+        #: Previous Y position, in 0-1 range.
+        self.psy = None
+        #: Previous Z position, in 0-1 range.
+        self.psz = None
+        #: Delta between self.sx and self.psx, in 0-1 range.
+        self.dsx = None
+        #: Delta between self.sy and self.psy, in 0-1 range.
+        self.dsy = None
+        #: Delta between self.sz and self.psz, in 0-1 range.
+        self.dsz = None
+        #: X position, in window range.
+        self.x = 0.0
+        #: Y position, in window range.
+        self.y = 0.0
+        #: Z position, in window range.
+        self.z = 0.0
+        #: Origin X position, in window range.
+        self.ox = None
+        #: Origin Y position, in window range.
+        self.oy = None
+        #: Origin Z position, in window range.
+        self.oz = None
+        #: Previous X position, in window range.
+        self.px = None
+        #: Previous Y position, in window range.
+        self.py = None
+        #: Previous Z position, in window range.
+        self.pz = None
+        #: Delta between self.x and self.px, in window range.
+        self.dx = None
+        #: Delta between self.y and self.py, in window range.
+        self.dy = None
+        #: Delta between self.z and self.pz, in window range.
+        self.dz = None
+        #: Position (X, Y), in window range.
+        self.pos = (0.0, 0.0)
+
+        #: Initial time of the event creation.
+        self.time_start = time()
+
+        #: Time of the last update.
+        self.time_update = self.time_start
+
+        #: Time of the end event (last event usage).
+        self.time_end = -1
+
+        #: Indicate if the touch event is a double tap or not.
+        self.is_double_tap = False
+
+        #: Indicate if the touch event is a triple tap or not.
+        #:
+        #: .. versionadded:: 1.7.0
+        self.is_triple_tap = False
+
+        #: If the touch is a :attr:`is_double_tap`, this is the time
+        #: between the previous tap and the current touch.
+        self.double_tap_time = 0
+
+        #: If the touch is a :attr:`is_triple_tap`, this is the time
+        #: between the first tap and the current touch.
+        #:
+        #: .. versionadded:: 1.7.0
+        self.triple_tap_time = 0
+
+        #: User data dictionary. Use this dictionary to save your own data on
+        #: the event.
+        self.ud = EnhancedDictionary()
+
+        #: If set to `True` (default) keeps first previous position
+        #: (X, Y, Z in 0-1 range) and ignore all other until
+        #: :meth:`MotionEvent.dispatch_done` is called from the `EventLoop`.
+        #:
+        #: This attribute is needed because event provider can make many calls
+        #: to :meth:`MotionEvent.move`, but for all those calls event is
+        #: dispatched to the listeners only once. Assigning `False` will keep
+        #: latest previous position. See :meth:`MotionEvent.move`.
+        #:
+        #: .. versionadded:: 2.1.0
+        self.sync_with_dispatch = True
+
+        #: Keep first previous position if :attr:`sync_with_dispatch` is
+        #: `True`.
+        self._keep_prev_pos = True
+
+        #: Flag that first dispatch of this event is done.
+        self._first_dispatch_done = False
+
+        self.depack(args)
+
+    def depack(self, args):
+        '''Depack `args` into attributes of the class'''
+        if self.osx is None \
+                or self.sync_with_dispatch and not self._first_dispatch_done:
+            # Sync origin/previous/current positions until the first
+            # dispatch (etype == 'begin') is done.
+            self.osx = self.psx = self.sx
+            self.osy = self.psy = self.sy
+            self.osz = self.psz = self.sz
+        # update the delta
+        self.dsx = self.sx - self.psx
+        self.dsy = self.sy - self.psy
+        self.dsz = self.sz - self.psz
+
+    def grab(self, class_instance, exclusive=False):
+        '''Grab this motion event.
+
+        If this event is a touch you can grab it if you want to receive
+        subsequent :meth:`~kivy.uix.widget.Widget.on_touch_move` and
+        :meth:`~kivy.uix.widget.Widget.on_touch_up` events, even if the touch
+        is not dispatched by the parent:
+
+        .. code-block:: python
+
+            def on_touch_down(self, touch):
+                touch.grab(self)
+
+            def on_touch_move(self, touch):
+                if touch.grab_current is self:
+                    # I received my grabbed touch
+                else:
+                    # it's a normal touch
+
+            def on_touch_up(self, touch):
+                if touch.grab_current is self:
+                    # I receive my grabbed touch, I must ungrab it!
+                    touch.ungrab(self)
+                else:
+                    # it's a normal touch
+                    pass
+
+        .. versionchanged:: 2.1.0
+            Allowed grab for non-touch events.
+        '''
+        if self.grab_exclusive_class is not None:
+            raise Exception('Event is exclusive and cannot be grabbed')
+        class_instance = weakref.ref(class_instance.__self__)
+        if exclusive:
+            self.grab_exclusive_class = class_instance
+        self.grab_list.append(class_instance)
+
+    def ungrab(self, class_instance):
+        '''Ungrab a previously grabbed motion event.
+        '''
+        class_instance = weakref.ref(class_instance.__self__)
+        if self.grab_exclusive_class == class_instance:
+            self.grab_exclusive_class = None
+        if class_instance in self.grab_list:
+            self.grab_list.remove(class_instance)
+
+    def dispatch_done(self):
+        '''Notify that dispatch to the listeners is done.
+
+        Called by the :meth:`EventLoopBase.post_dispatch_input`.
+
+        .. versionadded:: 2.1.0
+        '''
+        self._keep_prev_pos = True
+        self._first_dispatch_done = True
+
+    def move(self, args):
+        '''Move to another position.
+        '''
+        if self.sync_with_dispatch:
+            if self._keep_prev_pos:
+                self.psx, self.psy, self.psz = self.sx, self.sy, self.sz
+                self._keep_prev_pos = False
+        else:
+            self.psx, self.psy, self.psz = self.sx, self.sy, self.sz
+        self.time_update = time()
+        self.depack(args)
+
+    def scale_for_screen(self, w, h, p=None, rotation=0,
+                         smode='None', kheight=0):
+        '''Scale position for the screen.
+
+        .. versionchanged:: 2.1.0
+            Max value for `x`, `y` and `z` is changed respectively to `w` - 1,
+            `h` - 1 and `p` - 1.
+        '''
+        x_max, y_max = max(0, w - 1), max(0, h - 1)
+        absolute = self.to_absolute_pos
+        self.x, self.y = absolute(self.sx, self.sy, x_max, y_max, rotation)
+        self.ox, self.oy = absolute(self.osx, self.osy, x_max, y_max, rotation)
+        self.px, self.py = absolute(self.psx, self.psy, x_max, y_max, rotation)
+        z_max = 0 if p is None else max(0, p - 1)
+        self.z = self.sz * z_max
+        self.oz = self.osz * z_max
+        self.pz = self.psz * z_max
+        if smode:
+            # Adjust y for keyboard height
+            if smode == 'pan' or smode == 'below_target':
+                self.y -= kheight
+                self.oy -= kheight
+                self.py -= kheight
+            elif smode == 'scale':
+                offset = kheight * (self.y - h) / (h - kheight)
+                self.y += offset
+                self.oy += offset
+                self.py += offset
+        # Update delta values
+        self.dx = self.x - self.px
+        self.dy = self.y - self.py
+        self.dz = self.z - self.pz
+        # Cache position
+        self.pos = self.x, self.y
+
+    def to_absolute_pos(self, nx, ny, x_max, y_max, rotation):
+        '''Transforms normalized (0-1) coordinates `nx` and `ny` to absolute
+        coordinates using `x_max`, `y_max` and `rotation`.
+
+        :raises:
+            `ValueError`: If `rotation` is not one of: 0, 90, 180 or 270
+
+        .. versionadded:: 2.1.0
+        '''
+        if rotation == 0:
+            return nx * x_max, ny * y_max
+        elif rotation == 90:
+            return ny * y_max, (1 - nx) * x_max
+        elif rotation == 180:
+            return (1 - nx) * x_max, (1 - ny) * y_max
+        elif rotation == 270:
+            return (1 - ny) * y_max, nx * x_max
+        raise ValueError('Invalid rotation %s, '
+                         'valid values are 0, 90, 180 or 270' % rotation)
+
+    def push(self, attrs=None):
+        '''Push attribute values in `attrs` onto the stack.
+        '''
+        if attrs is None:
+            attrs = self.push_attrs
+        values = [getattr(self, x) for x in attrs]
+        self.push_attrs_stack.append((attrs, values))
+
+    def pop(self):
+        '''Pop attributes values from the stack.
+        '''
+        attrs, values = self.push_attrs_stack.pop()
+        for i in range(len(attrs)):
+            setattr(self, attrs[i], values[i])
+
+    def apply_transform_2d(self, transform):
+        '''Apply a transformation on x, y, z, px, py, pz,
+        ox, oy, oz, dx, dy, dz.
+        '''
+        self.x, self.y = self.pos = transform(self.x, self.y)
+        self.px, self.py = transform(self.px, self.py)
+        self.ox, self.oy = transform(self.ox, self.oy)
+        self.dx = self.x - self.px
+        self.dy = self.y - self.py
+
+    def copy_to(self, to):
+        '''Copy some attribute to another motion event object.'''
+        for attr in self.__attrs__:
+            to.__setattr__(attr, copy(self.__getattribute__(attr)))
+
+    def distance(self, other_touch):
+        '''Return the distance between the two events.
+        '''
+        return Vector(self.pos).distance(other_touch.pos)
+
+    def update_time_end(self):
+        self.time_end = time()
+
+    # facilities
+    @property
+    def dpos(self):
+        '''Return delta between last position and current position, in the
+        screen coordinate system (self.dx, self.dy).'''
+        return self.dx, self.dy
+
+    @property
+    def opos(self):
+        '''Return the initial position of the motion event in the screen
+        coordinate system (self.ox, self.oy).'''
+        return self.ox, self.oy
+
+    @property
+    def ppos(self):
+        '''Return the previous position of the motion event in the screen
+        coordinate system (self.px, self.py).'''
+        return self.px, self.py
+
+    @property
+    def spos(self):
+        '''Return the position in the 0-1 coordinate system (self.sx, self.sy).
+        '''
+        return self.sx, self.sy
+
+    def __str__(self):
+        basename = str(self.__class__)
+        classname = basename.split('.')[-1].replace('>', '').replace('\'', '')
+        return '<%s spos=%s pos=%s>' % (classname, self.spos, self.pos)
+
+    def __repr__(self):
+        out = []
+        for x in dir(self):
+            v = getattr(self, x)
+            if x[0] == '_':
+                continue
+            if isroutine(v):
+                continue
+            out.append('%s="%s"' % (x, v))
+        return '<%s %s>' % (
+            self.__class__.__name__,
+            ' '.join(out))
+
+    @property
+    def is_mouse_scrolling(self, *args):
+        '''Returns True if the touch event is a mousewheel scrolling
+
+        .. versionadded:: 1.6.0
+        '''
+        return 'button' in self.profile and 'scroll' in self.button
diff --git a/kivy/input/postproc/__init__.py b/kivy/input/postproc/__init__.py
new file mode 100644
index 0000000..8207454
--- /dev/null
+++ b/kivy/input/postproc/__init__.py
@@ -0,0 +1,27 @@
+'''
+Input Postprocessing
+====================
+
+'''
+
+__all__ = ('kivy_postproc_modules', )
+
+import os
+from kivy.input.postproc.doubletap import InputPostprocDoubleTap
+from kivy.input.postproc.tripletap import InputPostprocTripleTap
+from kivy.input.postproc.ignorelist import InputPostprocIgnoreList
+from kivy.input.postproc.retaintouch import InputPostprocRetainTouch
+from kivy.input.postproc.dejitter import InputPostprocDejitter
+from kivy.input.postproc.calibration import InputPostprocCalibration
+
+# Mapping of ID to module
+kivy_postproc_modules = {}
+
+# Don't go further if we generate documentation
+if 'KIVY_DOC' not in os.environ:
+    kivy_postproc_modules['calibration'] = InputPostprocCalibration()
+    kivy_postproc_modules['retaintouch'] = InputPostprocRetainTouch()
+    kivy_postproc_modules['ignorelist'] = InputPostprocIgnoreList()
+    kivy_postproc_modules['doubletap'] = InputPostprocDoubleTap()
+    kivy_postproc_modules['tripletap'] = InputPostprocTripleTap()
+    kivy_postproc_modules['dejitter'] = InputPostprocDejitter()
diff --git a/kivy/input/postproc/__pycache__/__init__.cpython-310.pyc b/kivy/input/postproc/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..0017f32
Binary files /dev/null and b/kivy/input/postproc/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/input/postproc/__pycache__/calibration.cpython-310.pyc b/kivy/input/postproc/__pycache__/calibration.cpython-310.pyc
new file mode 100644
index 0000000..017851a
Binary files /dev/null and b/kivy/input/postproc/__pycache__/calibration.cpython-310.pyc differ
diff --git a/kivy/input/postproc/__pycache__/dejitter.cpython-310.pyc b/kivy/input/postproc/__pycache__/dejitter.cpython-310.pyc
new file mode 100644
index 0000000..9831c84
Binary files /dev/null and b/kivy/input/postproc/__pycache__/dejitter.cpython-310.pyc differ
diff --git a/kivy/input/postproc/__pycache__/doubletap.cpython-310.pyc b/kivy/input/postproc/__pycache__/doubletap.cpython-310.pyc
new file mode 100644
index 0000000..fc9f309
Binary files /dev/null and b/kivy/input/postproc/__pycache__/doubletap.cpython-310.pyc differ
diff --git a/kivy/input/postproc/__pycache__/ignorelist.cpython-310.pyc b/kivy/input/postproc/__pycache__/ignorelist.cpython-310.pyc
new file mode 100644
index 0000000..a0ac87b
Binary files /dev/null and b/kivy/input/postproc/__pycache__/ignorelist.cpython-310.pyc differ
diff --git a/kivy/input/postproc/__pycache__/retaintouch.cpython-310.pyc b/kivy/input/postproc/__pycache__/retaintouch.cpython-310.pyc
new file mode 100644
index 0000000..3d8b9f1
Binary files /dev/null and b/kivy/input/postproc/__pycache__/retaintouch.cpython-310.pyc differ
diff --git a/kivy/input/postproc/__pycache__/tripletap.cpython-310.pyc b/kivy/input/postproc/__pycache__/tripletap.cpython-310.pyc
new file mode 100644
index 0000000..460341f
Binary files /dev/null and b/kivy/input/postproc/__pycache__/tripletap.cpython-310.pyc differ
diff --git a/kivy/input/postproc/calibration.py b/kivy/input/postproc/calibration.py
new file mode 100644
index 0000000..084e99b
--- /dev/null
+++ b/kivy/input/postproc/calibration.py
@@ -0,0 +1,200 @@
+'''
+Calibration
+===========
+
+.. versionadded:: 1.9.0
+
+Recalibrate input device to a specific range / offset.
+
+Let's say you have 3 1080p displays, the 2 firsts are multitouch. By default,
+both will have mixed touch, the range will conflict with each others: the 0-1
+range will goes to 0-5760 px (remember, 3 * 1920 = 5760.)
+
+To fix it, you need to manually reference them. For example::
+
+    [input]
+    left = mtdev,/dev/input/event17
+    middle = mtdev,/dev/input/event15
+    # the right screen is just a display.
+
+Then, you can use the calibration postproc module::
+
+    [postproc:calibration]
+    left = xratio=0.3333
+    middle = xratio=0.3333,xoffset=0.3333
+
+Now, the touches from the left screen will be within 0-0.3333 range, and the
+touches from the middle screen will be within 0.3333-0.6666 range.
+
+You can also match calibration rules to devices based on their provider type.
+This is useful when probesysfs is used to match devices. For example::
+
+    [input]
+    mtdev_%(name)s = probesysfs,provider=mtdev
+
+Then to apply calibration to any mtdev device, you can assign rules to the
+provider name enclosed by parentheses::
+
+    [postproc:calibration]
+    (mtdev) = xratio=0.3333,xoffset=0.3333
+
+Calibrating devices like this means the device's path doesn't need to be
+configured ahead of time. Note that with this method, all mtdev inputs will
+have the same calibration applied to them. For this reason, matching by
+provider will typically be useful when expecting only one input device.
+'''
+
+__all__ = ('InputPostprocCalibration', )
+
+from kivy.config import Config
+from kivy.logger import Logger
+from kivy.input import providers
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+
+
+class InputPostprocCalibration(object):
+    '''Recalibrate the inputs.
+
+    The configuration must go within a section named `postproc:calibration`.
+    Within the section, you must have a line like::
+
+        devicename = param=value,param=value
+
+    If you wish to match by provider, you must have a line like::
+
+        (provider) = param=value,param=value
+
+    :Parameters:
+        `xratio`: float
+            Value to multiply X
+        `yratio`: float
+            Value to multiply Y
+        `xoffset`: float
+            Value to add to X
+        `yoffset`: float
+            Value to add to Y
+        `auto`: str
+            If set, then the touch is transformed from screen-relative
+            to window-relative The value is used as an indication of
+            screen size, e.g for fullHD:
+
+                auto=1920x1080
+
+            If present, this setting overrides all the others.
+            This assumes the input device exactly covers the display
+            area, if they are different, the computations will be wrong.
+
+    .. versionchanged:: 1.11.0
+        Added `auto` parameter
+    '''
+
+    def __init__(self):
+        super(InputPostprocCalibration, self).__init__()
+        self.devices = {}
+        self.frame = 0
+        self.provider_map = self._get_provider_map()
+        if not Config.has_section('postproc:calibration'):
+            return
+        default_params = {'xoffset': 0, 'yoffset': 0, 'xratio': 1, 'yratio': 1}
+        for device_key, params_str in Config.items('postproc:calibration'):
+            params = default_params.copy()
+            for param in params_str.split(','):
+                param = param.strip()
+                if not param:
+                    continue
+                key, value = param.split('=', 1)
+                if key == 'auto':
+                    width, height = [float(x) for x in value.split('x')]
+                    params['auto'] = width, height
+                    break
+                if key not in ('xoffset', 'yoffset', 'xratio', 'yratio'):
+                    Logger.error(
+                        'Calibration: invalid key provided: {}'.format(key))
+                params[key] = float(value)
+            self.devices[device_key] = params
+
+    def _get_provider_map(self):
+        """Iterates through all registered input provider names and finds the
+        respective MotionEvent subclass for each. Returns a dict of MotionEvent
+        subclasses mapped to their provider name.
+        """
+        provider_map = {}
+        for input_provider in MotionEventFactory.list():
+            if not hasattr(providers, input_provider):
+                continue
+
+            p = getattr(providers, input_provider)
+            for m in p.__all__:
+                event = getattr(p, m)
+                if issubclass(event, MotionEvent):
+                    provider_map[event] = input_provider
+
+        return provider_map
+
+    def _get_provider_key(self, event):
+        """Returns the provider key for the event if the provider is configured
+        for calibration.
+        """
+        input_type = self.provider_map.get(event.__class__)
+        key = '({})'.format(input_type)
+        if input_type and key in self.devices:
+            return key
+
+    def process(self, events):
+        # avoid doing any processing if there is no device to calibrate at all.
+        if not self.devices:
+            return events
+
+        self.frame += 1
+        frame = self.frame
+        to_remove = []
+        for etype, event in events:
+            # frame-based logic below doesn't account for
+            # end events having been already processed
+            if etype == 'end':
+                continue
+
+            if event.device in self.devices:
+                dev = event.device
+            else:
+                dev = self._get_provider_key(event)
+            if not dev:
+                continue
+
+            # some providers use the same event to update and end
+            if 'calibration:frame' not in event.ud:
+                event.ud['calibration:frame'] = frame
+            elif event.ud['calibration:frame'] == frame:
+                continue
+            event.ud['calibration:frame'] = frame
+
+            params = self.devices[dev]
+            if 'auto' in params:
+                event.sx, event.sy = self.auto_calibrate(
+                    event.sx, event.sy, params['auto'])
+                if not (0 <= event.sx <= 1 and 0 <= event.sy <= 1):
+                    to_remove.append((etype, event))
+            else:
+                event.sx = event.sx * params['xratio'] + params['xoffset']
+                event.sy = event.sy * params['yratio'] + params['yoffset']
+
+        for event in to_remove:
+            events.remove(event)
+
+        return events
+
+    def auto_calibrate(self, sx, sy, size):
+        from kivy.core.window import Window as W
+        WIDTH, HEIGHT = size
+
+        xratio = WIDTH / W.width
+        yratio = HEIGHT / W.height
+
+        xoffset = - W.left / W.width
+        yoffset = - (HEIGHT - W.top - W.height) / W.height
+
+        sx = sx * xratio + xoffset
+        sy = sy * yratio + yoffset
+
+        return sx, sy
diff --git a/kivy/input/postproc/dejitter.py b/kivy/input/postproc/dejitter.py
new file mode 100644
index 0000000..ff7147f
--- /dev/null
+++ b/kivy/input/postproc/dejitter.py
@@ -0,0 +1,74 @@
+'''
+Dejitter
+========
+
+Prevent blob jittering.
+
+A problem that is often faced (esp. in optical MT setups) is that of
+jitterish BLOBs caused by bad camera characteristics. With this module
+you can get rid of that jitter. You just define a threshold
+`jitter_distance` in your config, and all touch movements that move
+the touch by less than the jitter distance are considered 'bad'
+movements caused by jitter and will be discarded.
+'''
+
+__all__ = ('InputPostprocDejitter', )
+
+from kivy.config import Config
+
+
+class InputPostprocDejitter(object):
+    '''
+    Get rid of jitterish BLOBs.
+    Example::
+
+        [postproc]
+        jitter_distance = 0.004
+        jitter_ignore_devices = mouse,mactouch
+
+    :Configuration:
+        `jitter_distance`: float
+            A float in range 0-1.
+        `jitter_ignore_devices`: string
+            A comma-separated list of device identifiers that
+            should not be processed by dejitter (because they're
+            very precise already).
+    '''
+
+    def __init__(self):
+        self.jitterdist = Config.getfloat('postproc', 'jitter_distance')
+        ignore_devices = Config.get('postproc', 'jitter_ignore_devices')
+        self.ignore_devices = ignore_devices.split(',')
+        self.last_touches = {}
+
+    def taxicab_distance(self, p, q):
+        # Get the taxicab/manhattan/citiblock distance for efficiency reasons
+        return abs(p[0] - q[0]) + abs(p[1] - q[1])
+
+    def process(self, events):
+        if not self.jitterdist:
+            return events
+        processed = []
+        for etype, touch in events:
+            if not touch.is_touch:
+                continue
+            if touch.device in self.ignore_devices:
+                processed.append((etype, touch))
+                continue
+            if etype == 'begin':
+                self.last_touches[touch.id] = touch.spos
+            if etype == 'end':
+                if touch.id in self.last_touches:
+                    del self.last_touches[touch.id]
+            if etype != 'update':
+                processed.append((etype, touch))
+                continue
+            # Check whether the touch moved more than the jitter distance
+            last_spos = self.last_touches[touch.id]
+            dist = self.taxicab_distance(last_spos, touch.spos)
+            if dist > self.jitterdist:
+                # Only if the touch has moved more than the jitter dist we take
+                # it into account and dispatch it. Otherwise suppress it.
+                self.last_touches[touch.id] = touch.spos
+                processed.append((etype, touch))
+        return processed
diff --git a/kivy/input/postproc/doubletap.py b/kivy/input/postproc/doubletap.py
new file mode 100644
index 0000000..443109f
--- /dev/null
+++ b/kivy/input/postproc/doubletap.py
@@ -0,0 +1,101 @@
+'''
+Double Tap
+==========
+
+Search touch for a double tap
+'''
+
+__all__ = ('InputPostprocDoubleTap', )
+
+from time import time
+from kivy.config import Config
+from kivy.vector import Vector
+
+
+class InputPostprocDoubleTap(object):
+    '''
+    InputPostProcDoubleTap is a post-processor to check if
+    a touch is a double tap or not.
+    Double tap can be configured in the Kivy config file::
+
+        [postproc]
+        double_tap_time = 250
+        double_tap_distance = 20
+
+    Distance parameter is in the range 0-1000 and time is in milliseconds.
+    '''
+
+    def __init__(self):
+        dist = Config.getint('postproc', 'double_tap_distance')
+        self.double_tap_distance = dist / 1000.0
+        tap_time = Config.getint('postproc', 'double_tap_time')
+        self.double_tap_time = tap_time / 1000.0
+        self.touches = {}
+
+    def find_double_tap(self, ref):
+        '''Find a double tap touch within self.touches.
+        The touch must be not a previous double tap and the distance must be
+        within the specified threshold. Additionally, the touch profiles
+        must be the same kind of touch.
+        '''
+        ref_button = None
+        if 'button' in ref.profile:
+            ref_button = ref.button
+
+        for touchid in self.touches:
+            if ref.uid == touchid:
+                continue
+            etype, touch = self.touches[touchid]
+            if etype != 'end':
+                continue
+            if touch.is_double_tap:
+                continue
+            distance = Vector.distance(
+                Vector(ref.sx, ref.sy),
+                Vector(touch.osx, touch.osy))
+            if distance > self.double_tap_distance:
+                continue
+            if touch.is_mouse_scrolling or ref.is_mouse_scrolling:
+                continue
+            touch_button = None
+            if 'button' in touch.profile:
+                touch_button = touch.button
+            if touch_button != ref_button:
+                continue
+            touch.double_tap_distance = distance
+            return touch
+
+    def process(self, events):
+        if self.double_tap_distance == 0 or self.double_tap_time == 0:
+            return events
+        # first, check if a touch down have a double tap
+        for etype, touch in events:
+            if not touch.is_touch:
+                continue
+            if etype == 'begin':
+                double_tap = self.find_double_tap(touch)
+                if double_tap:
+                    touch.is_double_tap = True
+                    tap_time = touch.time_start - double_tap.time_start
+                    touch.double_tap_time = tap_time
+                    distance = double_tap.double_tap_distance
+                    touch.double_tap_distance = distance
+
+            # add the touch internally
+            self.touches[touch.uid] = (etype, touch)
+
+        # second, check if up-touch is timeout for double tap
+        time_current = time()
+        to_delete = []
+        for touchid in self.touches.keys():
+            etype, touch = self.touches[touchid]
+            if etype != 'end':
+                continue
+            if time_current - touch.time_start < self.double_tap_time:
+                continue
+            to_delete.append(touchid)
+
+        for touchid in to_delete:
+            del self.touches[touchid]
+
+        return events
diff --git a/kivy/input/postproc/ignorelist.py b/kivy/input/postproc/ignorelist.py
new file mode 100644
index 0000000..a5ceaf4
--- /dev/null
+++ b/kivy/input/postproc/ignorelist.py
@@ -0,0 +1,47 @@
+'''
+Ignore list
+===========
+
+Ignore touch on some areas of the screen
+'''
+
+__all__ = ('InputPostprocIgnoreList', )
+
+from kivy.config import Config
+from kivy.utils import strtotuple
+
+
+class InputPostprocIgnoreList(object):
+    '''
+    InputPostprocIgnoreList is a post-processor which removes touches in the
+    Ignore list. The Ignore list can be configured in the Kivy config file::
+
+        [postproc]
+        # Format: [(xmin, ymin, xmax, ymax), ...]
+        ignore = [(0.1, 0.1, 0.15, 0.15)]
+
+    The Ignore list coordinates are in the range 0-1, not in screen pixels.
+    '''
+
+    def __init__(self):
+        self.ignore_list = strtotuple(Config.get('postproc', 'ignore'))
+
+    def collide_ignore(self, touch):
+        x, y = touch.sx, touch.sy
+        for l in self.ignore_list:
+            xmin, ymin, xmax, ymax = l
+            if x > xmin and x < xmax and y > ymin and y < ymax:
+                return True
+
+    def process(self, events):
+        if not len(self.ignore_list):
+            return events
+        for etype, touch in events:
+            if not touch.is_touch:
+                continue
+            if etype != 'begin':
+                continue
+            if self.collide_ignore(touch):
+                touch.ud.__pp_ignore__ = True
+        return [(etype, touch) for etype, touch in events
+                if '__pp_ignore__' not in touch.ud]
diff --git a/kivy/input/postproc/retaintouch.py b/kivy/input/postproc/retaintouch.py
new file mode 100644
index 0000000..2dcc6f8
--- /dev/null
+++ b/kivy/input/postproc/retaintouch.py
@@ -0,0 +1,93 @@
+'''
+Retain Touch
+============
+
+Reuse touch to counter lost finger behavior
+'''
+
+__all__ = ('InputPostprocRetainTouch', )
+
+from kivy.config import Config
+from kivy.vector import Vector
+import time
+
+
+class InputPostprocRetainTouch(object):
+    '''
+    InputPostprocRetainTouch is a post-processor to delay the 'up' event of a
+    touch, to reuse it under certains conditions. This module is designed to
+    prevent lost finger touches on some hardware/setups.
+
+    Retain touch can be configured in the Kivy config file::
+
+        [postproc]
+            retain_time = 100
+            retain_distance = 50
+
+    The distance parameter is in the range 0-1000 and time is in milliseconds.
+    '''
+
+    def __init__(self):
+        self.timeout = Config.getint('postproc', 'retain_time') / 1000.0
+        self.distance = Config.getint('postproc', 'retain_distance') / 1000.0
+        self._available = []
+        self._links = {}
+
+    def process(self, events):
+        # check if module is disabled
+        if self.timeout == 0:
+            return events
+
+        d = time.time()
+        for etype, touch in events[:]:
+            if not touch.is_touch:
+                continue
+            if etype == 'end':
+                events.remove((etype, touch))
+                if touch.uid in self._links:
+                    selection = self._links[touch.uid]
+                    selection.ud.__pp_retain_time__ = d
+                    self._available.append(selection)
+                    del self._links[touch.uid]
+                else:
+                    touch.ud.__pp_retain_time__ = d
+                    self._available.append(touch)
+            elif etype == 'update':
+                if touch.uid in self._links:
+                    selection = self._links[touch.uid]
+                    selection.x = touch.x
+                    selection.y = touch.y
+                    selection.sx = touch.sx
+                    selection.sy = touch.sy
+                    events.remove((etype, touch))
+                    events.append((etype, selection))
+                else:
+                    pass
+            elif etype == 'begin':
+                # new touch, found the nearest one
+                selection = None
+                selection_distance = 99999
+                for touch2 in self._available:
+                    touch_distance = Vector(touch2.spos).distance(touch.spos)
+                    if touch_distance > self.distance:
+                        continue
+                    if touch2.__class__ != touch.__class__:
+                        continue
+                    if touch_distance < selection_distance:
+                        # eligible for continuation
+                        selection_distance = touch_distance
+                        selection = touch2
+                if selection is None:
+                    continue
+
+                self._links[touch.uid] = selection
+                self._available.remove(selection)
+                events.remove((etype, touch))
+
+        for touch in self._available[:]:
+            t = touch.ud.__pp_retain_time__
+            if d - t > self.timeout:
+                self._available.remove(touch)
+                events.append(('end', touch))
+
+        return events
diff --git a/kivy/input/postproc/tripletap.py b/kivy/input/postproc/tripletap.py
new file mode 100644
index 0000000..16ff2e5
--- /dev/null
+++ b/kivy/input/postproc/tripletap.py
@@ -0,0 +1,106 @@
+'''
+Triple Tap
+==========
+
+.. versionadded:: 1.7.0
+
+Search touch for a triple tap
+'''
+
+__all__ = ('InputPostprocTripleTap', )
+
+from time import time
+from kivy.config import Config
+from kivy.vector import Vector
+
+
+class InputPostprocTripleTap(object):
+    '''
+    InputPostProcTripleTap is a post-processor to check if
+    a touch is a triple tap or not.
+    Triple tap can be configured in the Kivy config file::
+
+        [postproc]
+        triple_tap_time = 250
+        triple_tap_distance = 20
+
+    The distance parameter is in the range 0-1000 and time is in milliseconds.
+    '''
+
+    def __init__(self):
+        dist = Config.getint('postproc', 'triple_tap_distance')
+        self.triple_tap_distance = dist / 1000.0
+        time = Config.getint('postproc', 'triple_tap_time')
+        self.triple_tap_time = time / 1000.0
+        self.touches = {}
+
+    def find_triple_tap(self, ref):
+        '''Find a triple tap touch within *self.touches*.
+        The touch must be not be a previous triple tap and the distance
+        must be be within the bounds specified. Additionally, the touch profile
+        must be the same kind of touch.
+        '''
+        ref_button = None
+        if 'button' in ref.profile:
+            ref_button = ref.button
+
+        for touchid in self.touches:
+            if ref.uid == touchid:
+                continue
+            etype, touch = self.touches[touchid]
+            if not touch.is_double_tap:
+                continue
+            if etype != 'end':
+                continue
+            if touch.is_triple_tap:
+                continue
+            distance = Vector.distance(
+                Vector(ref.sx, ref.sy),
+                Vector(touch.osx, touch.osy))
+            if distance > self.triple_tap_distance:
+                continue
+            if touch.is_mouse_scrolling or ref.is_mouse_scrolling:
+                continue
+            touch_button = None
+            if 'button' in touch.profile:
+                touch_button = touch.button
+            if touch_button != ref_button:
+                continue
+            touch.triple_tap_distance = distance
+            return touch
+
+    def process(self, events):
+        if self.triple_tap_distance == 0 or self.triple_tap_time == 0:
+            return events
+        # first, check if a touch down have a triple tap
+        for etype, touch in events:
+            if not touch.is_touch:
+                continue
+            if etype == 'begin':
+                triple_tap = self.find_triple_tap(touch)
+                if triple_tap:
+                    touch.is_double_tap = False
+                    touch.is_triple_tap = True
+                    tap_time = touch.time_start - triple_tap.time_start
+                    touch.triple_tap_time = tap_time
+                    distance = triple_tap.triple_tap_distance
+                    touch.triple_tap_distance = distance
+
+            # add the touch internally
+            self.touches[touch.uid] = (etype, touch)
+
+        # second, check if up-touch is timeout for triple tap
+        time_current = time()
+        to_delete = []
+        for touchid in self.touches.keys():
+            etype, touch = self.touches[touchid]
+            if etype != 'end':
+                continue
+            if time_current - touch.time_start < self.triple_tap_time:
+                continue
+            to_delete.append(touchid)
+
+        for touchid in to_delete:
+            del self.touches[touchid]
+
+        return events
diff --git a/kivy/input/provider.py b/kivy/input/provider.py
new file mode 100644
index 0000000..f5ebafa
--- /dev/null
+++ b/kivy/input/provider.py
@@ -0,0 +1,40 @@
+'''
+Motion Event Provider
+=====================
+
+Abstract class for the implementation of a
+:class:`~kivy.input.motionevent.MotionEvent`
+provider. The implementation must support the
+:meth:`~MotionEventProvider.start`, :meth:`~MotionEventProvider.stop` and
+:meth:`~MotionEventProvider.update` methods.
+'''
+
+__all__ = ('MotionEventProvider', )
+
+
+class MotionEventProvider(object):
+    '''Base class for a provider.
+    '''
+
+    def __init__(self, device, args):
+        self.device = device
+        if self.__class__ == MotionEventProvider:
+            raise NotImplementedError('class MotionEventProvider is abstract')
+
+    def start(self):
+        '''Start the provider. This method is automatically called when the
+        application is started and if the configuration uses the current
+        provider.
+        '''
+        pass
+
+    def stop(self):
+        '''Stop the provider.
+        '''
+        pass
+
+    def update(self, dispatch_fn):
+        '''Update the provider and dispatch all the new touch events though the
+        `dispatch_fn` argument.
+        '''
+        pass
diff --git a/kivy/input/providers/__init__.py b/kivy/input/providers/__init__.py
new file mode 100644
index 0000000..8e0b84d
--- /dev/null
+++ b/kivy/input/providers/__init__.py
@@ -0,0 +1,68 @@
+# pylint: disable=W0611
+'''
+Providers
+=========
+
+'''
+
+import os
+
+from kivy.utils import platform as core_platform
+from kivy.logger import Logger
+from kivy.setupconfig import USE_SDL2
+
+import kivy.input.providers.tuio
+import kivy.input.providers.mouse
+
+platform = core_platform
+
+if platform == 'win' or 'KIVY_DOC' in os.environ:
+    try:
+        import kivy.input.providers.wm_touch
+        import kivy.input.providers.wm_pen
+    except:
+        err = 'Input: WM_Touch/WM_Pen not supported by your version of Windows'
+        Logger.warning(err)
+
+if platform == 'macosx' or 'KIVY_DOC' in os.environ:
+    try:
+        import kivy.input.providers.mactouch
+    except:
+        err = 'Input: MacMultitouchSupport is not supported by your system'
+        Logger.exception(err)
+
+if platform == 'linux' or 'KIVY_DOC' in os.environ:
+    try:
+        import kivy.input.providers.probesysfs
+    except:
+        err = 'Input: ProbeSysfs is not supported by your version of linux'
+        Logger.exception(err)
+    try:
+        import kivy.input.providers.mtdev
+    except:
+        err = 'Input: MTDev is not supported by your version of linux'
+        Logger.exception(err)
+    try:
+        import kivy.input.providers.hidinput
+    except:
+        err = 'Input: HIDInput is not supported by your version of linux'
+        Logger.exception(err)
+    try:
+        import kivy.input.providers.linuxwacom
+    except:
+        err = 'Input: LinuxWacom is not supported by your version of linux'
+        Logger.exception(err)
+
+if (platform == 'android' and not USE_SDL2) or 'KIVY_DOC' in os.environ:
+    try:
+        import kivy.input.providers.androidjoystick
+    except:
+        err = 'Input: AndroidJoystick is not supported by your version ' \
+              'of linux'
+        Logger.exception(err)
+
+try:
+    import kivy.input.providers.leapfinger  # NOQA
+except:
+    err = 'Input: LeapFinger is not available on your system'
+    Logger.exception(err)
diff --git a/kivy/input/providers/__pycache__/__init__.cpython-310.pyc b/kivy/input/providers/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..95e1d81
Binary files /dev/null and b/kivy/input/providers/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/androidjoystick.cpython-310.pyc b/kivy/input/providers/__pycache__/androidjoystick.cpython-310.pyc
new file mode 100644
index 0000000..abedaa7
Binary files /dev/null and b/kivy/input/providers/__pycache__/androidjoystick.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/hidinput.cpython-310.pyc b/kivy/input/providers/__pycache__/hidinput.cpython-310.pyc
new file mode 100644
index 0000000..55c3bdb
Binary files /dev/null and b/kivy/input/providers/__pycache__/hidinput.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/leapfinger.cpython-310.pyc b/kivy/input/providers/__pycache__/leapfinger.cpython-310.pyc
new file mode 100644
index 0000000..d9f8168
Binary files /dev/null and b/kivy/input/providers/__pycache__/leapfinger.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/linuxwacom.cpython-310.pyc b/kivy/input/providers/__pycache__/linuxwacom.cpython-310.pyc
new file mode 100644
index 0000000..696d6e0
Binary files /dev/null and b/kivy/input/providers/__pycache__/linuxwacom.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/mactouch.cpython-310.pyc b/kivy/input/providers/__pycache__/mactouch.cpython-310.pyc
new file mode 100644
index 0000000..79a73da
Binary files /dev/null and b/kivy/input/providers/__pycache__/mactouch.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/mouse.cpython-310.pyc b/kivy/input/providers/__pycache__/mouse.cpython-310.pyc
new file mode 100644
index 0000000..6a5f202
Binary files /dev/null and b/kivy/input/providers/__pycache__/mouse.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/mtdev.cpython-310.pyc b/kivy/input/providers/__pycache__/mtdev.cpython-310.pyc
new file mode 100644
index 0000000..9a78054
Binary files /dev/null and b/kivy/input/providers/__pycache__/mtdev.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/probesysfs.cpython-310.pyc b/kivy/input/providers/__pycache__/probesysfs.cpython-310.pyc
new file mode 100644
index 0000000..a8a5865
Binary files /dev/null and b/kivy/input/providers/__pycache__/probesysfs.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/tuio.cpython-310.pyc b/kivy/input/providers/__pycache__/tuio.cpython-310.pyc
new file mode 100644
index 0000000..b6b1e48
Binary files /dev/null and b/kivy/input/providers/__pycache__/tuio.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/wm_common.cpython-310.pyc b/kivy/input/providers/__pycache__/wm_common.cpython-310.pyc
new file mode 100644
index 0000000..049fe1e
Binary files /dev/null and b/kivy/input/providers/__pycache__/wm_common.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/wm_pen.cpython-310.pyc b/kivy/input/providers/__pycache__/wm_pen.cpython-310.pyc
new file mode 100644
index 0000000..277e444
Binary files /dev/null and b/kivy/input/providers/__pycache__/wm_pen.cpython-310.pyc differ
diff --git a/kivy/input/providers/__pycache__/wm_touch.cpython-310.pyc b/kivy/input/providers/__pycache__/wm_touch.cpython-310.pyc
new file mode 100644
index 0000000..56d51ba
Binary files /dev/null and b/kivy/input/providers/__pycache__/wm_touch.cpython-310.pyc differ
diff --git a/kivy/input/providers/androidjoystick.py b/kivy/input/providers/androidjoystick.py
new file mode 100644
index 0000000..5c8aae3
--- /dev/null
+++ b/kivy/input/providers/androidjoystick.py
@@ -0,0 +1,117 @@
+# pylint: disable=W0611
+'''
+Android Joystick Input Provider
+===============================
+
+This module is based on the PyGame JoyStick Input Provider. For more
+information, please refer to
+`<http://www.pygame.org/docs/ref/joystick.html>`_
+
+
+'''
+__all__ = ('AndroidMotionEventProvider', )
+
+import os
+
+try:
+    import android  # NOQA
+except ImportError:
+    if 'KIVY_DOC' not in os.environ:
+        raise Exception('android lib not found.')
+
+from kivy.logger import Logger
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.shape import ShapeRect
+from kivy.input.motionevent import MotionEvent
+if 'KIVY_DOC' not in os.environ:
+    import pygame.joystick
+
+
+class AndroidMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ['pos', 'pressure', 'shape']
+
+    def depack(self, args):
+        self.sx, self.sy, self.pressure, radius = args
+        self.shape = ShapeRect()
+        self.shape.width = radius
+        self.shape.height = radius
+        super().depack(args)
+
+
+class AndroidMotionEventProvider(MotionEventProvider):
+
+    def __init__(self, device, args):
+        super(AndroidMotionEventProvider, self).__init__(device, args)
+        self.joysticks = []
+        self.touches = {}
+        self.uid = 0
+        self.window = None
+
+    def create_joystick(self, index):
+        Logger.info('Android: create joystick <%d>' % index)
+        js = pygame.joystick.Joystick(index)
+        js.init()
+        if js.get_numbuttons() == 0:
+            Logger.info('Android: discard joystick <%d> cause no button' %
+                        index)
+            return
+        self.joysticks.append(js)
+
+    def start(self):
+        pygame.joystick.init()
+        Logger.info('Android: found %d joystick' % pygame.joystick.get_count())
+        for i in range(pygame.joystick.get_count()):
+            self.create_joystick(i)
+
+    def stop(self):
+        self.joysticks = []
+
+    def update(self, dispatch_fn):
+        if not self.window:
+            from kivy.core.window import Window
+            self.window = Window
+        w, h = self.window.system_size
+        touches = self.touches
+        for joy in self.joysticks:
+            jid = joy.get_id()
+            pressed = joy.get_button(0)
+            if pressed or jid in touches:
+                x = joy.get_axis(0) * 32768. / w
+                y = 1. - (joy.get_axis(1) * 32768. / h)
+
+                # python for android do * 1000.
+                pressure = joy.get_axis(2) / 1000.
+                radius = joy.get_axis(3) / 1000.
+
+                # new touch ?
+                if pressed and jid not in touches:
+                    self.uid += 1
+                    touch = AndroidMotionEvent(self.device, self.uid,
+                                            [x, y, pressure, radius])
+                    touches[jid] = touch
+                    dispatch_fn('begin', touch)
+                # update touch
+                elif pressed:
+                    touch = touches[jid]
+                    # avoid same touch position
+                    if (touch.sx == x and touch.sy == y and
+                            touch.pressure == pressure):
+                        continue
+                    touch.move([x, y, pressure, radius])
+                    dispatch_fn('update', touch)
+                # disappear
+                elif not pressed and jid in touches:
+                    touch = touches[jid]
+                    touch.move([x, y, pressure, radius])
+                    touch.update_time_end()
+                    dispatch_fn('end', touch)
+                    touches.pop(jid)
+
+
+MotionEventFactory.register('android', AndroidMotionEventProvider)
diff --git a/kivy/input/providers/hidinput.py b/kivy/input/providers/hidinput.py
new file mode 100644
index 0000000..4004136
--- /dev/null
+++ b/kivy/input/providers/hidinput.py
@@ -0,0 +1,778 @@
+# coding utf-8
+'''
+Native support for HID input from the linux kernel
+==================================================
+
+Support starts from 2.6.32-ubuntu, or 2.6.34.
+
+To configure HIDInput, add this to your configuration::
+
+    [input]
+    # devicename = hidinput,/dev/input/eventXX
+    # example with Stantum MTP4.3" screen
+    stantum = hidinput,/dev/input/event2
+
+.. note::
+    You must have read access to the input event.
+
+You can use a custom range for the X, Y and pressure values.
+For some drivers, the range reported is invalid.
+To fix that, you can add these options to the argument line:
+
+* invert_x : 1 to invert X axis
+* invert_y : 1 to invert Y axis
+* min_position_x : X relative minimum
+* max_position_x : X relative maximum
+* min_position_y : Y relative minimum
+* max_position_y : Y relative maximum
+* min_abs_x : X absolute minimum
+* min_abs_y : Y absolute minimum
+* max_abs_x : X absolute maximum
+* max_abs_y : Y absolute maximum
+* min_pressure : pressure minimum
+* max_pressure : pressure maximum
+* rotation : rotate the input coordinate (0, 90, 180, 270)
+
+For example, on the Asus T101M, the touchscreen reports a range from 0-4095 for
+the X and Y values, but the real values are in a range from 0-32768. To correct
+this, you can add the following to the configuration::
+
+    [input]
+    t101m = hidinput,/dev/input/event7,max_position_x=32768,\
+max_position_y=32768
+
+.. versionadded:: 1.9.1
+
+    `rotation` configuration token added.
+
+'''
+import os
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+__all__ = ('HIDInputMotionEventProvider', 'HIDMotionEvent')
+
+# late imports
+Window = None
+Keyboard = None
+
+
+class HIDMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+
+    def depack(self, args):
+        self.sx = args['x']
+        self.sy = args['y']
+        self.profile = ['pos']
+        if 'size_w' in args and 'size_h' in args:
+            self.shape = ShapeRect()
+            self.shape.width = args['size_w']
+            self.shape.height = args['size_h']
+            self.profile.append('shape')
+        if 'pressure' in args:
+            self.pressure = args['pressure']
+            self.profile.append('pressure')
+        if 'button' in args:
+            self.button = args['button']
+            self.profile.append('button')
+        super().depack(args)
+
+    def __str__(self):
+        return '<HIDMotionEvent id=%d pos=(%f, %f) device=%s>' \
+            % (self.id, self.sx, self.sy, self.device)
+
+
+if 'KIVY_DOC' in os.environ:
+    # documentation hack
+    HIDInputMotionEventProvider = None
+
+else:
+    import threading
+    import collections
+    import struct
+    import fcntl
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+    from kivy.logger import Logger
+
+    #
+    # This part is taken from linux-source-2.6.32/include/linux/input.h
+    #
+
+    # Event types
+    EV_SYN = 0x00
+    EV_KEY = 0x01
+    EV_REL = 0x02
+    EV_ABS = 0x03
+    EV_MSC = 0x04
+    EV_SW = 0x05
+    EV_LED = 0x11
+    EV_SND = 0x12
+    EV_REP = 0x14
+    EV_FF = 0x15
+    EV_PWR = 0x16
+    EV_FF_STATUS = 0x17
+    EV_MAX = 0x1f
+    EV_CNT = (EV_MAX + 1)
+
+    KEY_MAX = 0x2ff
+
+    # Synchronization events
+    SYN_REPORT = 0
+    SYN_CONFIG = 1
+    SYN_MT_REPORT = 2
+
+    # Misc events
+    MSC_SERIAL = 0x00
+    MSC_PULSELED = 0x01
+    MSC_GESTURE = 0x02
+    MSC_RAW = 0x03
+    MSC_SCAN = 0x04
+    MSC_MAX = 0x07
+    MSC_CNT = (MSC_MAX + 1)
+
+    ABS_X = 0x00
+    ABS_Y = 0x01
+    ABS_PRESSURE = 0x18
+    ABS_MT_TOUCH_MAJOR = 0x30  # Major axis of touching ellipse
+    ABS_MT_TOUCH_MINOR = 0x31  # Minor axis (omit if circular)
+    ABS_MT_WIDTH_MAJOR = 0x32  # Major axis of approaching ellipse
+    ABS_MT_WIDTH_MINOR = 0x33  # Minor axis (omit if circular)
+    ABS_MT_ORIENTATION = 0x34  # Ellipse orientation
+    ABS_MT_POSITION_X = 0x35   # Center X ellipse position
+    ABS_MT_POSITION_Y = 0x36   # Center Y ellipse position
+    ABS_MT_TOOL_TYPE = 0x37    # Type of touching device
+    ABS_MT_BLOB_ID = 0x38      # Group a set of packets as a blob
+    ABS_MT_TRACKING_ID = 0x39  # Unique ID of initiated contact
+    ABS_MT_PRESSURE = 0x3a     # Pressure on contact area
+
+    # some ioctl base (with 0 value)
+    EVIOCGNAME = 2147501318
+    EVIOCGBIT = 2147501344
+    EVIOCGABS = 2149074240
+
+    keyboard_keys = {
+        0x29: ('`', '~'),
+        0x02: ('1', '!'),
+        0x03: ('2', '@'),
+        0x04: ('3', '#'),
+        0x05: ('4', '$'),
+        0x06: ('5', '%'),
+        0x07: ('6', '^'),
+        0x08: ('7', '&'),
+        0x09: ('8', '*'),
+        0x0a: ('9', '('),
+        0x0b: ('0', ')'),
+        0x0c: ('-', '_'),
+        0x0d: ('=', '+'),
+        0x0e: ('backspace', ),
+        0x0f: ('tab', ),
+        0x10: ('q', 'Q'),
+        0x11: ('w', 'W'),
+        0x12: ('e', 'E'),
+        0x13: ('r', 'R'),
+        0x14: ('t', 'T'),
+        0x15: ('y', 'Y'),
+        0x16: ('u', 'U'),
+        0x17: ('i', 'I'),
+        0x18: ('o', 'O'),
+        0x19: ('p', 'P'),
+        0x1a: ('[', '{'),
+        0x1b: (']', '}'),
+        0x2b: ('\\', '|'),
+        0x3a: ('capslock', ),
+        0x1e: ('a', 'A'),
+        0x1f: ('s', 'S'),
+        0x20: ('d', 'D'),
+        0x21: ('f', 'F'),
+        0x22: ('g', 'G'),
+        0x23: ('h', 'H'),
+        0x24: ('j', 'J'),
+        0x25: ('k', 'K'),
+        0x26: ('l', 'L'),
+        0x27: (';', ':'),
+        0x28: ("'", '"'),
+        0xff: ('non-US-1', ),
+        0x1c: ('enter', ),
+        0x2a: ('shift', ),
+        0x2c: ('z', 'Z'),
+        0x2d: ('x', 'X'),
+        0x2e: ('c', 'C'),
+        0x2f: ('v', 'V'),
+        0x30: ('b', 'B'),
+        0x31: ('n', 'N'),
+        0x32: ('m', 'M'),
+        0x33: (',', '<'),
+        0x34: ('.', '>'),
+        0x35: ('/', '?'),
+        0x36: ('shift', ),
+        0x56: ('pipe', ),
+        0x1d: ('lctrl', ),
+        0x7D: ('super', ),
+        0x38: ('alt', ),
+        0x39: ('spacebar', ),
+        0x64: ('alt-gr', ),
+        0x7e: ('super', ),
+        0x7f: ('compose', ),
+        0x61: ('rctrl', ),
+        0x45: ('numlock', ),
+        0x47: ('numpad7', 'home'),
+        0x4b: ('numpad4', 'left'),
+        0x4f: ('numpad1', 'end'),
+        0x48: ('numpad8', 'up'),
+        0x4c: ('numpad5', ),
+        0x50: ('numpad2', 'down'),
+        0x52: ('numpad0', 'insert'),
+        0x37: ('numpadmul', ),
+        0x62: ('numpaddivide', ),
+        0x49: ('numpad9', 'pageup'),
+        0x4d: ('numpad6', 'right'),
+        0x51: ('numpad3', 'pagedown'),
+        0x53: ('numpaddecimal', 'delete'),
+        0x4a: ('numpadsubstract', ),
+        0x4e: ('numpadadd', ),
+        0x60: ('numpadenter', ),
+        0x01: ('escape', ),
+        0x3b: ('f1', ),
+        0x3c: ('f2', ),
+        0x3d: ('f3', ),
+        0x3e: ('f4', ),
+        0x3f: ('f5', ),
+        0x40: ('f6', ),
+        0x41: ('f7', ),
+        0x42: ('f8', ),
+        0x43: ('f9', ),
+        0x44: ('f10', ),
+        0x57: ('f11', ),
+        0x58: ('f12', ),
+        0x54: ('Alt+SysRq', ),
+        0x46: ('Screenlock', ),
+        0x67: ('up', ),
+        0x6c: ('down', ),
+        0x69: ('left', ),
+        0x6a: ('right', ),
+        0x6e: ('insert', ),
+        0x6f: ('delete', ),
+        0x66: ('home', ),
+        0x6b: ('end', ),
+        0x68: ('pageup', ),
+        0x6d: ('pagedown', ),
+        0x63: ('print', ),
+        0x77: ('pause', ),
+
+
+        # TODO combinations
+        # e0-37    PrtScr
+        # e0-46    Ctrl+Break
+        # e0-5b    LWin (USB: LGUI)
+        # e0-5c    RWin (USB: RGUI)
+        # e0-5d    Menu
+        # e0-5f    Sleep
+        # e0-5e    Power
+        # e0-63    Wake
+        # e0-38    RAlt
+        # e0-1d    RCtrl
+        # e0-52    Insert
+        # e0-53    Delete
+        # e0-47    Home
+        # e0-4f    End
+        # e0-49    PgUp
+        # e0-51    PgDn
+        # e0-4b    Left
+        # e0-48    Up
+        # e0-50    Down
+        # e0-4d    Right
+        # e0-35    KP-/
+        # e0-1c    KP-Enter
+        # e1-1d-45 77      Pause
+    }
+
+    keys_str = {
+        'spacebar': ' ',
+        'tab': '	',
+        'shift': '',
+        'alt': '',
+        'ctrl': '',
+        'escape': '',
+        'numpad1': '1',
+        'numpad2': '2',
+        'numpad3': '3',
+        'numpad4': '4',
+        'numpad5': '5',
+        'numpad6': '6',
+        'numpad7': '7',
+        'numpad8': '8',
+        'numpad9': '9',
+        'numpad0': '0',
+        'numpadmul': '*',
+        'numpaddivide': '/',
+        'numpadadd': '+',
+        'numpaddecimal': '.',
+        'numpadsubstract': '-',
+    }
+
+    # sizeof(struct input_event)
+    struct_input_event_sz = struct.calcsize('LLHHi')
+    struct_input_absinfo_sz = struct.calcsize('iiiiii')
+    sz_l = struct.calcsize('Q')
+
+    class HIDInputMotionEventProvider(MotionEventProvider):
+
+        options = ('min_position_x', 'max_position_x',
+                   'min_position_y', 'max_position_y',
+                   'min_pressure', 'max_pressure',
+                   'min_abs_x', 'max_abs_x',
+                   'min_abs_y', 'max_abs_y',
+                   'invert_x', 'invert_y', 'rotation')
+
+        def __init__(self, device, args):
+            super(HIDInputMotionEventProvider, self).__init__(device, args)
+            global Window, Keyboard
+
+            if Window is None:
+                from kivy.core.window import Window
+            if Keyboard is None:
+                from kivy.core.window import Keyboard
+
+            self.input_fn = None
+            self.default_ranges = dict()
+
+            # split arguments
+            args = args.split(',')
+            if not args:
+                Logger.error('HIDInput: Filename missing in configuration')
+                Logger.error('HIDInput: Use /dev/input/event0 for example')
+                return None
+
+            # read filename
+            self.input_fn = args[0]
+            Logger.info('HIDInput: Read event from <%s>' % self.input_fn)
+
+            # read parameters
+            for arg in args[1:]:
+                if arg == '':
+                    continue
+                arg = arg.split('=')
+
+                # ensure it's a key = value
+                if len(arg) != 2:
+                    Logger.error('HIDInput: invalid parameter '
+                                 '%s, not in key=value format.' % arg)
+                    continue
+
+                # ensure the key exist
+                key, value = arg
+                if key not in HIDInputMotionEventProvider.options:
+                    Logger.error('HIDInput: unknown %s option' % key)
+                    continue
+
+                # ensure the value
+                try:
+                    self.default_ranges[key] = int(value)
+                except ValueError:
+                    err = 'HIDInput: invalid value "%s" for "%s"' % (
+                        key, value)
+                    Logger.error(err)
+                    continue
+
+                # all good!
+                Logger.info('HIDInput: Set custom %s to %d' % (
+                    key, int(value)))
+
+            if 'rotation' not in self.default_ranges:
+                self.default_ranges['rotation'] = 0
+            elif self.default_ranges['rotation'] not in (0, 90, 180, 270):
+                Logger.error('HIDInput: invalid rotation value ({})'.format(
+                    self.default_ranges['rotation']))
+                self.default_ranges['rotation'] = 0
+
+        def start(self):
+            if self.input_fn is None:
+                return
+            self.uid = 0
+            self.queue = collections.deque()
+            self.dispatch_queue = []
+            self.thread = threading.Thread(
+                name=self.__class__.__name__,
+                target=self._thread_run,
+                kwargs=dict(
+                    queue=self.queue,
+                    input_fn=self.input_fn,
+                    device=self.device,
+                    default_ranges=self.default_ranges))
+            self.thread.daemon = True
+            self.thread.start()
+
+        def _thread_run(self, **kwargs):
+            input_fn = kwargs.get('input_fn')
+            queue = self.queue
+            dispatch_queue = self.dispatch_queue
+            device = kwargs.get('device')
+            drs = kwargs.get('default_ranges').get
+            touches = {}
+            touches_sent = []
+            point = {}
+            l_points = []
+
+            # prepare some vars to get limit of some component
+            range_min_position_x = 0
+            range_max_position_x = 2048
+            range_min_position_y = 0
+            range_max_position_y = 2048
+            range_min_pressure = 0
+            range_max_pressure = 255
+            range_min_abs_x = 0
+            range_max_abs_x = 255
+            range_min_abs_y = 0
+            range_max_abs_y = 255
+            range_min_abs_pressure = 0
+            range_max_abs_pressure = 255
+            invert_x = int(bool(drs('invert_x', 0)))
+            invert_y = int(bool(drs('invert_y', 1)))
+            rotation = drs('rotation', 0)
+
+            def assign_coord(point, value, invert, coords):
+                cx, cy = coords
+                if invert:
+                    value = 1. - value
+                if rotation == 0:
+                    point[cx] = value
+                elif rotation == 90:
+                    point[cy] = value
+                elif rotation == 180:
+                    point[cx] = 1. - value
+                elif rotation == 270:
+                    point[cy] = 1. - value
+
+            def assign_rel_coord(point, value, invert, coords):
+                cx, cy = coords
+                if invert:
+                    value = -1 * value
+                if rotation == 0:
+                    point[cx] += value
+                elif rotation == 90:
+                    point[cy] += value
+                elif rotation == 180:
+                    point[cx] += -value
+                elif rotation == 270:
+                    point[cy] += -value
+
+                # limit it to the screen area 0-1
+                point['x'] = min(1., max(0., point['x']))
+                point['y'] = min(1., max(0., point['y']))
+
+            def process_as_multitouch(tv_sec, tv_usec, ev_type,
+                                      ev_code, ev_value):
+                # sync event
+                if ev_type == EV_SYN:
+                    if ev_code == SYN_MT_REPORT:
+                        if 'id' not in point:
+                            return
+                        l_points.append(point.copy())
+                    elif ev_code == SYN_REPORT:
+                        process(l_points)
+                        del l_points[:]
+
+                elif ev_type == EV_MSC and ev_code in (MSC_RAW, MSC_SCAN):
+                    pass
+
+                else:
+                    # compute multitouch track
+                    if ev_code == ABS_MT_TRACKING_ID:
+                        point.clear()
+                        point['id'] = ev_value
+                    elif ev_code == ABS_MT_POSITION_X:
+                        val = normalize(ev_value,
+                                        range_min_position_x,
+                                        range_max_position_x)
+                        assign_coord(point, val, invert_x, 'xy')
+                    elif ev_code == ABS_MT_POSITION_Y:
+                        val = 1. - normalize(ev_value,
+                                             range_min_position_y,
+                                             range_max_position_y)
+                        assign_coord(point, val, invert_y, 'yx')
+                    elif ev_code == ABS_MT_ORIENTATION:
+                        point['orientation'] = ev_value
+                    elif ev_code == ABS_MT_BLOB_ID:
+                        point['blobid'] = ev_value
+                    elif ev_code == ABS_MT_PRESSURE:
+                        point['pressure'] = normalize(ev_value,
+                                                      range_min_pressure,
+                                                      range_max_pressure)
+                    elif ev_code == ABS_MT_TOUCH_MAJOR:
+                        point['size_w'] = ev_value
+                    elif ev_code == ABS_MT_TOUCH_MINOR:
+                        point['size_h'] = ev_value
+
+            def process_as_mouse_or_keyboard(
+                    tv_sec, tv_usec, ev_type, ev_code, ev_value):
+                if ev_type == EV_SYN:
+                    if ev_code == SYN_REPORT:
+                        process([point])
+                        if ('button' in point and
+                                point['button'].startswith('scroll')):
+                            # for scrolls we need to remove it as there is
+                            # no up key
+                            del point['button']
+                            point['id'] += 1
+                            point['_avoid'] = True
+                            process([point])
+
+                elif ev_type == EV_REL:
+                    if ev_code == 0:
+                        assign_rel_coord(point,
+                                         min(1., max(-1., ev_value / 1000.)),
+                                         invert_x, 'xy')
+                    elif ev_code == 1:
+                        assign_rel_coord(point,
+                                         min(1., max(-1., ev_value / 1000.)),
+                                         invert_y, 'yx')
+                    elif ev_code == 8:  # Wheel
+                        # translates the wheel move to a button
+                        b = "scrollup" if ev_value < 0 else "scrolldown"
+                        if 'button' not in point:
+                            point['button'] = b
+                            point['id'] += 1
+                            if '_avoid' in point:
+                                del point['_avoid']
+
+                elif ev_type != EV_KEY:
+                    if ev_code == ABS_X:
+                        val = normalize(ev_value,
+                                        range_min_abs_x,
+                                        range_max_abs_x)
+                        assign_coord(point, val, invert_x, 'xy')
+                    elif ev_code == ABS_Y:
+                        val = 1. - normalize(ev_value,
+                                             range_min_abs_y,
+                                             range_max_abs_y)
+                        assign_coord(point, val, invert_y, 'yx')
+                    elif ev_code == ABS_PRESSURE:
+                        point['pressure'] = normalize(ev_value,
+                                                      range_min_abs_pressure,
+                                                      range_max_abs_pressure)
+                else:
+                    buttons = {
+                        272: 'left',
+                        273: 'right',
+                        274: 'middle',
+                        275: 'side',
+                        276: 'extra',
+                        277: 'forward',
+                        278: 'back',
+                        279: 'task',
+                        330: 'touch',
+                        320: 'pen'}
+
+                    if ev_code in buttons.keys():
+                        if ev_value:
+                            if 'button' not in point:
+                                point['button'] = buttons[ev_code]
+                                point['id'] += 1
+                                if '_avoid' in point:
+                                    del point['_avoid']
+                        elif 'button' in point:
+                            if point['button'] == buttons[ev_code]:
+                                del point['button']
+                                point['id'] += 1
+                                point['_avoid'] = True
+                    else:
+                        if not 0 <= ev_value <= 1:
+                            return
+
+                        if ev_code not in keyboard_keys:
+                            Logger.warn('HIDInput: unhandled HID code: {}'.
+                                        format(ev_code))
+                            return
+
+                        z = keyboard_keys[ev_code][-1 if 'shift' in
+                                                   Window._modifiers else 0]
+                        if z.lower() not in Keyboard.keycodes:
+                            # or if it is not in this LUT
+                            Logger.warn('HIDInput: unhandled character: {}'.
+                                        format(z))
+                            return
+
+                        keycode = Keyboard.keycodes[z.lower()]
+
+                        if ev_value == 1:
+                            if z == 'shift' or z == 'alt':
+                                Window._modifiers.append(z)
+                            elif z.endswith('ctrl'):
+                                Window._modifiers.append('ctrl')
+
+                            dispatch_queue.append(('key_down', (
+                                keycode, ev_code,
+                                keys_str.get(z, z), Window._modifiers)))
+                        elif ev_value == 0:
+                            dispatch_queue.append(('key_up', (
+                                keycode, ev_code,
+                                keys_str.get(z, z), Window._modifiers)))
+                            if ((z == 'shift' or z == 'alt') and
+                                    (z in Window._modifiers)):
+                                Window._modifiers.remove(z)
+                            elif (z.endswith('ctrl') and
+                                  'ctrl' in Window._modifiers):
+                                Window._modifiers.remove('ctrl')
+
+            def process(points):
+                if not is_multitouch:
+                    dispatch_queue.append(('mouse_pos', (
+                        points[0]['x'] * Window.width,
+                        points[0]['y'] * Window.height)))
+
+                actives = [args['id']
+                           for args in points
+                           if 'id' in args and '_avoid' not in args]
+                for args in points:
+                    tid = args['id']
+                    try:
+                        touch = touches[tid]
+                        if touch.sx == args['x'] and touch.sy == args['y']:
+                            continue
+                        touch.move(args)
+                        if tid not in touches_sent:
+                            queue.append(('begin', touch))
+                            touches_sent.append(tid)
+                        queue.append(('update', touch))
+                    except KeyError:
+                        if '_avoid' not in args:
+                            touch = HIDMotionEvent(device, tid, args)
+                            touches[touch.id] = touch
+                            if tid not in touches_sent:
+                                queue.append(('begin', touch))
+                                touches_sent.append(tid)
+
+                for tid in list(touches.keys())[:]:
+                    if tid not in actives:
+                        touch = touches[tid]
+                        if tid in touches_sent:
+                            touch.update_time_end()
+                            queue.append(('end', touch))
+                            touches_sent.remove(tid)
+                        del touches[tid]
+
+            def normalize(value, vmin, vmax):
+                return (value - vmin) / float(vmax - vmin)
+
+            # open the input
+            fd = open(input_fn, 'rb')
+
+            # get the controller name (EVIOCGNAME)
+            device_name = fcntl.ioctl(fd, EVIOCGNAME + (256 << 16),
+                                      " " * 256).decode().strip()
+            Logger.info('HIDMotionEvent: using <%s>' % device_name)
+
+            # get abs infos
+            bit = fcntl.ioctl(fd, EVIOCGBIT + (EV_MAX << 16), ' ' * sz_l)
+            bit, = struct.unpack('Q', bit)
+            is_multitouch = False
+            for x in range(EV_MAX):
+                # preserve this, we may want other things than EV_ABS
+                if x != EV_ABS:
+                    continue
+                # EV_ABS available for this device ?
+                if (bit & (1 << x)) == 0:
+                    continue
+                # ask abs info keys to the devices
+                sbit = fcntl.ioctl(fd, EVIOCGBIT + x + (KEY_MAX << 16),
+                                   ' ' * sz_l)
+                sbit, = struct.unpack('Q', sbit)
+                for y in range(KEY_MAX):
+                    if (sbit & (1 << y)) == 0:
+                        continue
+                    absinfo = fcntl.ioctl(fd, EVIOCGABS + y +
+                                          (struct_input_absinfo_sz << 16),
+                                          ' ' * struct_input_absinfo_sz)
+                    abs_value, abs_min, abs_max, abs_fuzz, \
+                        abs_flat, abs_res = struct.unpack('iiiiii', absinfo)
+                    if y == ABS_MT_POSITION_X:
+                        is_multitouch = True
+                        range_min_position_x = drs('min_position_x', abs_min)
+                        range_max_position_x = drs('max_position_x', abs_max)
+                        Logger.info('HIDMotionEvent: ' +
+                                    '<%s> range position X is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+                    elif y == ABS_MT_POSITION_Y:
+                        is_multitouch = True
+                        range_min_position_y = drs('min_position_y', abs_min)
+                        range_max_position_y = drs('max_position_y', abs_max)
+                        Logger.info('HIDMotionEvent: ' +
+                                    '<%s> range position Y is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+                    elif y == ABS_MT_PRESSURE:
+                        range_min_pressure = drs('min_pressure', abs_min)
+                        range_max_pressure = drs('max_pressure', abs_max)
+                        Logger.info('HIDMotionEvent: ' +
+                                    '<%s> range pressure is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+                    elif y == ABS_X:
+                        range_min_abs_x = drs('min_abs_x', abs_min)
+                        range_max_abs_x = drs('max_abs_x', abs_max)
+                        Logger.info('HIDMotionEvent: ' +
+                                    '<%s> range ABS X position is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+                    elif y == ABS_Y:
+                        range_min_abs_y = drs('min_abs_y', abs_min)
+                        range_max_abs_y = drs('max_abs_y', abs_max)
+                        Logger.info('HIDMotionEvent: ' +
+                                    '<%s> range ABS Y position is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+                    elif y == ABS_PRESSURE:
+                        range_min_abs_pressure = drs(
+                            'min_abs_pressure', abs_min)
+                        range_max_abs_pressure = drs(
+                            'max_abs_pressure', abs_max)
+                        Logger.info('HIDMotionEvent: ' +
+                                    '<%s> range ABS pressure is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+
+            # init the point
+            if not is_multitouch:
+                point = {'x': .5, 'y': .5, 'id': 0, '_avoid': True}
+
+            # read until the end
+            while fd:
+
+                data = fd.read(struct_input_event_sz)
+                if len(data) < struct_input_event_sz:
+                    break
+
+                # extract each event
+                for i in range(int(len(data) / struct_input_event_sz)):
+                    ev = data[i * struct_input_event_sz:]
+
+                    # extract timeval + event infos
+                    infos = struct.unpack('LLHHi', ev[:struct_input_event_sz])
+
+                    if is_multitouch:
+                        process_as_multitouch(*infos)
+                    else:
+                        process_as_mouse_or_keyboard(*infos)
+
+        def update(self, dispatch_fn):
+            # dispatch all events from threads
+            dispatch_queue = self.dispatch_queue
+            n = len(dispatch_queue)
+            for name, args in dispatch_queue[:n]:
+                if name == 'mouse_pos':
+                    Window.mouse_pos = args
+                elif name == 'key_down':
+                    if not Window.dispatch('on_key_down', *args):
+                        Window.dispatch('on_keyboard', *args)
+                elif name == 'key_up':
+                    Window.dispatch('on_key_up', *args)
+            del dispatch_queue[:n]
+
+            try:
+                while True:
+                    event_type, touch = self.queue.popleft()
+                    dispatch_fn(event_type, touch)
+            except:
+                pass
+
+    MotionEventFactory.register('hidinput', HIDInputMotionEventProvider)
diff --git a/kivy/input/providers/leapfinger.py b/kivy/input/providers/leapfinger.py
new file mode 100644
index 0000000..42540b3
--- /dev/null
+++ b/kivy/input/providers/leapfinger.py
@@ -0,0 +1,113 @@
+'''
+Leap Motion - finger only
+=========================
+'''
+
+__all__ = ('LeapFingerEventProvider', 'LeapFingerEvent')
+
+from collections import deque
+from kivy.logger import Logger
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+
+_LEAP_QUEUE = deque()
+
+Leap = InteractionBox = None
+
+
+def normalize(value, a, b):
+    return (value - a) / float(b - a)
+
+
+class LeapFingerEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'pos3d',)
+
+    def depack(self, args):
+        super().depack(args)
+        if args[0] is None:
+            return
+        x, y, z = args
+        self.sx = normalize(x, -150, 150)
+        self.sy = normalize(y, 40, 460)
+        self.sz = normalize(z, -350, 350)
+        self.z = z
+
+
+class LeapFingerEventProvider(MotionEventProvider):
+
+    __handlers__ = {}
+
+    def start(self):
+        # don't do the import at start, or the error will be always displayed
+        # for user who don't have Leap
+        global Leap, InteractionBox
+        import Leap
+        from Leap import InteractionBox
+
+        class LeapMotionListener(Leap.Listener):
+
+            def on_init(self, controller):
+                Logger.info('leapmotion: Initialized')
+
+            def on_connect(self, controller):
+                Logger.info('leapmotion: Connected')
+
+            def on_disconnect(self, controller):
+                Logger.info('leapmotion: Disconnected')
+
+            def on_frame(self, controller):
+                frame = controller.frame()
+                _LEAP_QUEUE.append(frame)
+
+            def on_exit(self, controller):
+                pass
+
+        self.uid = 0
+        self.touches = {}
+        self.listener = LeapMotionListener()
+        self.controller = Leap.Controller(self.listener)
+
+    def update(self, dispatch_fn):
+        try:
+            while True:
+                frame = _LEAP_QUEUE.popleft()
+                events = self.process_frame(frame)
+                for ev in events:
+                    dispatch_fn(*ev)
+        except IndexError:
+            pass
+
+    def process_frame(self, frame):
+        events = []
+        touches = self.touches
+        available_uid = []
+        for hand in frame.hands:
+            for finger in hand.fingers:
+                # print(hand.id(), finger.id(), finger.tip())
+                uid = '{0}:{1}'.format(hand.id, finger.id)
+                available_uid.append(uid)
+                position = finger.tip_position
+                args = (position.x, position.y, position.z)
+                if uid not in touches:
+                    touch = LeapFingerEvent(self.device, uid, args)
+                    events.append(('begin', touch))
+                    touches[uid] = touch
+                else:
+                    touch = touches[uid]
+                    touch.move(args)
+                    events.append(('update', touch))
+        for key in list(touches.keys())[:]:
+            if key not in available_uid:
+                events.append(('end', touches[key]))
+                del touches[key]
+        return events
+
+
+# registers
+MotionEventFactory.register('leapfinger', LeapFingerEventProvider)
diff --git a/kivy/input/providers/linuxwacom.py b/kivy/input/providers/linuxwacom.py
new file mode 100644
index 0000000..ba97058
--- /dev/null
+++ b/kivy/input/providers/linuxwacom.py
@@ -0,0 +1,396 @@
+'''
+Native support of Wacom tablet from linuxwacom driver
+=====================================================
+
+To configure LinuxWacom, add this to your configuration::
+
+    [input]
+    pen = linuxwacom,/dev/input/event2,mode=pen
+    finger = linuxwacom,/dev/input/event3,mode=touch
+
+.. note::
+    You must have read access to the input event.
+
+You can use a custom range for the X, Y and pressure values.
+On some drivers, the range reported is invalid.
+To fix that, you can add these options to the argument line:
+
+* invert_x : 1 to invert X axis
+* invert_y : 1 to invert Y axis
+* min_position_x : X minimum
+* max_position_x : X maximum
+* min_position_y : Y minimum
+* max_position_y : Y maximum
+* min_pressure : pressure minimum
+* max_pressure : pressure maximum
+'''
+
+__all__ = ('LinuxWacomMotionEventProvider', 'LinuxWacomMotionEvent')
+
+import os
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+
+class LinuxWacomMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+
+    def depack(self, args):
+        self.sx = args['x']
+        self.sy = args['y']
+        self.profile = ['pos']
+        if 'size_w' in args and 'size_h' in args:
+            self.shape = ShapeRect()
+            self.shape.width = args['size_w']
+            self.shape.height = args['size_h']
+            self.profile.append('shape')
+        if 'pressure' in args:
+            self.pressure = args['pressure']
+            self.profile.append('pressure')
+        super().depack(args)
+
+    def __str__(self):
+        return '<LinuxWacomMotionEvent id=%d pos=(%f, %f) device=%s>' \
+            % (self.id, self.sx, self.sy, self.device)
+
+
+if 'KIVY_DOC' in os.environ:
+    # documentation hack
+    LinuxWacomMotionEventProvider = None
+
+else:
+    import threading
+    import collections
+    import struct
+    import fcntl
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+    from kivy.logger import Logger
+
+    #
+    # This part is taken from linux-source-2.6.32/include/linux/input.h
+    #
+
+    # Event types
+    EV_SYN = 0x00
+    EV_KEY = 0x01
+    EV_REL = 0x02
+    EV_ABS = 0x03
+    EV_MSC = 0x04
+    EV_SW = 0x05
+    EV_LED = 0x11
+    EV_SND = 0x12
+    EV_REP = 0x14
+    EV_FF = 0x15
+    EV_PWR = 0x16
+    EV_FF_STATUS = 0x17
+    EV_MAX = 0x1f
+    EV_CNT = (EV_MAX + 1)
+
+    KEY_MAX = 0x2ff
+
+    # Synchronization events
+    SYN_REPORT = 0
+    SYN_CONFIG = 1
+    SYN_MT_REPORT = 2
+
+    # Misc events
+    MSC_SERIAL = 0x00
+    MSC_PULSELED = 0x01
+    MSC_GESTURE = 0x02
+    MSC_RAW = 0x03
+    MSC_SCAN = 0x04
+    MSC_MAX = 0x07
+    MSC_CNT = (MSC_MAX + 1)
+
+    ABS_X = 0x00
+    ABS_Y = 0x01
+    ABS_PRESSURE = 0x18
+    ABS_MISC = 0x28  # if 0, it's touch up
+    ABS_MT_TOUCH_MAJOR = 0x30  # Major axis of touching ellipse
+    ABS_MT_TOUCH_MINOR = 0x31  # Minor axis (omit if circular)
+    ABS_MT_WIDTH_MAJOR = 0x32  # Major axis of approaching ellipse
+    ABS_MT_WIDTH_MINOR = 0x33  # Minor axis (omit if circular)
+    ABS_MT_ORIENTATION = 0x34  # Ellipse orientation
+    ABS_MT_POSITION_X = 0x35   # Center X ellipse position
+    ABS_MT_POSITION_Y = 0x36   # Center Y ellipse position
+    ABS_MT_TOOL_TYPE = 0x37    # Type of touching device
+    ABS_MT_BLOB_ID = 0x38      # Group a set of packets as a blob
+    ABS_MT_TRACKING_ID = 0x39  # Unique ID of initiated contact
+    ABS_MT_PRESSURE = 0x3a     # Pressure on contact area
+
+    # some ioctl base (with 0 value)
+    EVIOCGNAME = 2147501318
+    EVIOCGBIT = 2147501344
+    EVIOCGABS = 2149074240
+
+    # sizeof(struct input_event)
+    struct_input_event_sz = struct.calcsize('LLHHi')
+    struct_input_absinfo_sz = struct.calcsize('iiiiii')
+    sz_l = struct.calcsize('Q')
+
+    class LinuxWacomMotionEventProvider(MotionEventProvider):
+
+        options = ('min_position_x', 'max_position_x',
+                   'min_position_y', 'max_position_y',
+                   'min_pressure', 'max_pressure',
+                   'invert_x', 'invert_y')
+
+        def __init__(self, device, args):
+            super(LinuxWacomMotionEventProvider, self).__init__(device, args)
+            self.input_fn = None
+            self.default_ranges = dict()
+            self.mode = 'touch'
+
+            # split arguments
+            args = args.split(',')
+            if not args:
+                Logger.error('LinuxWacom: No filename given in config')
+                Logger.error('LinuxWacom: Use /dev/input/event0 for example')
+                return
+
+            # read filename
+            self.input_fn = args[0]
+            Logger.info('LinuxWacom: Read event from <%s>' % self.input_fn)
+
+            # read parameters
+            for arg in args[1:]:
+                if arg == '':
+                    continue
+                arg = arg.split('=')
+
+                # ensure it's a key = value
+                if len(arg) != 2:
+                    err = 'LinuxWacom: Bad parameter' \
+                        '%s: Not in key=value format.' % arg
+                    Logger.error(err)
+                    continue
+
+                # ensure the key exist
+                key, value = arg
+                if key == 'mode':
+                    self.mode = value
+                    continue
+
+                if key not in LinuxWacomMotionEventProvider.options:
+                    Logger.error('LinuxWacom: unknown %s option' % key)
+                    continue
+
+                # ensure the value
+                try:
+                    self.default_ranges[key] = int(value)
+                except ValueError:
+                    err = 'LinuxWacom: value %s invalid for %s' % (key, value)
+                    Logger.error(err)
+                    continue
+
+                # all good!
+                msg = 'LinuxWacom: Set custom %s to %d' % (key, int(value))
+                Logger.info(msg)
+            Logger.info('LinuxWacom: mode is <%s>' % self.mode)
+
+        def start(self):
+            if self.input_fn is None:
+                return
+            self.uid = 0
+            self.queue = collections.deque()
+            self.thread = threading.Thread(
+                target=self._thread_run,
+                kwargs=dict(
+                    queue=self.queue,
+                    input_fn=self.input_fn,
+                    device=self.device,
+                    default_ranges=self.default_ranges))
+            self.thread.daemon = True
+            self.thread.start()
+
+        def _thread_run(self, **kwargs):
+            input_fn = kwargs.get('input_fn')
+            queue = kwargs.get('queue')
+            device = kwargs.get('device')
+            drs = kwargs.get('default_ranges').get
+            touches = {}
+            touches_sent = []
+            l_points = {}
+
+            # prepare some vars to get limit of some component
+            range_min_position_x = 0
+            range_max_position_x = 2048
+            range_min_position_y = 0
+            range_max_position_y = 2048
+            range_min_pressure = 0
+            range_max_pressure = 255
+            invert_x = int(bool(drs('invert_x', 0)))
+            invert_y = int(bool(drs('invert_y', 0)))
+            reset_touch = False
+
+            def process(points):
+                actives = list(points.keys())
+                for args in points.values():
+                    tid = args['id']
+                    try:
+                        touch = touches[tid]
+                    except KeyError:
+                        touch = LinuxWacomMotionEvent(device, tid, args)
+                        touches[touch.id] = touch
+                    if touch.sx == args['x'] \
+                            and touch.sy == args['y'] \
+                            and tid in touches_sent:
+                        continue
+                    touch.move(args)
+                    if tid not in touches_sent:
+                        queue.append(('begin', touch))
+                        touches_sent.append(tid)
+                    queue.append(('update', touch))
+
+                for tid in list(touches.keys())[:]:
+                    if tid not in actives:
+                        touch = touches[tid]
+                        if tid in touches_sent:
+                            touch.update_time_end()
+                            queue.append(('end', touch))
+                            touches_sent.remove(tid)
+                        del touches[tid]
+
+            def normalize(value, vmin, vmax):
+                return (value - vmin) / float(vmax - vmin)
+
+            # open the input
+            try:
+                fd = open(input_fn, 'rb')
+            except IOError:
+                Logger.exception('Unable to open %s' % input_fn)
+                return
+
+            # get the controller name (EVIOCGNAME)
+            device_name = fcntl.ioctl(fd, EVIOCGNAME + (256 << 16),
+                                      " " * 256).split('\x00')[0]
+            Logger.info('LinuxWacom: using <%s>' % device_name)
+
+            # get abs infos
+            bit = fcntl.ioctl(fd, EVIOCGBIT + (EV_MAX << 16), ' ' * sz_l)
+            bit, = struct.unpack('Q', bit)
+            for x in range(EV_MAX):
+                # preserve this, we may want other things than EV_ABS
+                if x != EV_ABS:
+                    continue
+                # EV_ABS available for this device ?
+                if (bit & (1 << x)) == 0:
+                    continue
+                # ask abs info keys to the devices
+                sbit = fcntl.ioctl(fd, EVIOCGBIT + x + (KEY_MAX << 16),
+                                   ' ' * sz_l)
+                sbit, = struct.unpack('Q', sbit)
+                for y in range(KEY_MAX):
+                    if (sbit & (1 << y)) == 0:
+                        continue
+                    absinfo = fcntl.ioctl(fd, EVIOCGABS + y +
+                                          (struct_input_absinfo_sz << 16),
+                                          ' ' * struct_input_absinfo_sz)
+                    abs_value, abs_min, abs_max, abs_fuzz, \
+                        abs_flat, abs_res = struct.unpack('iiiiii', absinfo)
+                    if y == ABS_X:
+                        range_min_position_x = drs('min_position_x', abs_min)
+                        range_max_position_x = drs('max_position_x', abs_max)
+                        Logger.info('LinuxWacom: ' +
+                                    '<%s> range position X is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+                    elif y == ABS_Y:
+                        range_min_position_y = drs('min_position_y', abs_min)
+                        range_max_position_y = drs('max_position_y', abs_max)
+                        Logger.info('LinuxWacom: ' +
+                                    '<%s> range position Y is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+                    elif y == ABS_PRESSURE:
+                        range_min_pressure = drs('min_pressure', abs_min)
+                        range_max_pressure = drs('max_pressure', abs_max)
+                        Logger.info('LinuxWacom: ' +
+                                    '<%s> range pressure is %d - %d' % (
+                                        device_name, abs_min, abs_max))
+
+            # read until the end
+            changed = False
+            touch_id = 0
+            touch_x = 0
+            touch_y = 0
+            touch_pressure = 0
+            while fd:
+
+                data = fd.read(struct_input_event_sz)
+                if len(data) < struct_input_event_sz:
+                    break
+
+                # extract each event
+                for i in range(len(data) / struct_input_event_sz):
+                    ev = data[i * struct_input_event_sz:]
+
+                    # extract timeval + event infos
+                    tv_sec, tv_usec, ev_type, ev_code, ev_value = \
+                        struct.unpack('LLHHi', ev[:struct_input_event_sz])
+
+                    if ev_type == EV_SYN and ev_code == SYN_REPORT:
+                        if touch_id in l_points:
+                            p = l_points[touch_id]
+                        else:
+                            p = dict()
+                            l_points[touch_id] = p
+                        p['id'] = touch_id
+                        if not reset_touch:
+                            p['x'] = touch_x
+                            p['y'] = touch_y
+                            p['pressure'] = touch_pressure
+                        if self.mode == 'pen' \
+                                and touch_pressure == 0 \
+                                and not reset_touch:
+                            del l_points[touch_id]
+                        if changed:
+                            if 'x' not in p:
+                                reset_touch = False
+                                continue
+                            process(l_points)
+                            changed = False
+                        if reset_touch:
+                            l_points.clear()
+                            reset_touch = False
+                            process(l_points)
+                    elif ev_type == EV_MSC and ev_code == MSC_SERIAL:
+                        touch_id = ev_value
+                    elif ev_type == EV_ABS and ev_code == ABS_X:
+                        val = normalize(ev_value,
+                                        range_min_position_x,
+                                        range_max_position_x)
+                        if invert_x:
+                            val = 1. - val
+                        touch_x = val
+                        changed = True
+                    elif ev_type == EV_ABS and ev_code == ABS_Y:
+                        val = 1. - normalize(ev_value,
+                                             range_min_position_y,
+                                             range_max_position_y)
+                        if invert_y:
+                            val = 1. - val
+                        touch_y = val
+                        changed = True
+                    elif ev_type == EV_ABS and ev_code == ABS_PRESSURE:
+                        touch_pressure = normalize(ev_value,
+                                                   range_min_pressure,
+                                                   range_max_pressure)
+                        changed = True
+                    elif ev_type == EV_ABS and ev_code == ABS_MISC:
+                        if ev_value == 0:
+                            reset_touch = True
+
+        def update(self, dispatch_fn):
+            # dispatch all event from threads
+            try:
+                while True:
+                    event_type, touch = self.queue.popleft()
+                    dispatch_fn(event_type, touch)
+            except:
+                pass
+
+    MotionEventFactory.register('linuxwacom', LinuxWacomMotionEventProvider)
diff --git a/kivy/input/providers/mactouch.py b/kivy/input/providers/mactouch.py
new file mode 100644
index 0000000..39c6eb6
--- /dev/null
+++ b/kivy/input/providers/mactouch.py
@@ -0,0 +1,220 @@
+'''
+Native support of MultitouchSupport framework for MacBook (MaxOSX platform)
+===========================================================================
+'''
+
+__all__ = ('MacMotionEventProvider', )
+
+import ctypes
+import threading
+import collections
+import os
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+if 'KIVY_DOC' not in os.environ:
+    CFArrayRef = ctypes.c_void_p
+    CFMutableArrayRef = ctypes.c_void_p
+    CFIndex = ctypes.c_long
+
+    dll = '/System/Library/PrivateFrameworks/' + \
+        'MultitouchSupport.framework/MultitouchSupport'
+    MultitouchSupport = ctypes.CDLL(dll)
+
+    CFArrayGetCount = MultitouchSupport.CFArrayGetCount
+    CFArrayGetCount.argtypes = [CFArrayRef]
+    CFArrayGetCount.restype = CFIndex
+
+    CFArrayGetValueAtIndex = MultitouchSupport.CFArrayGetValueAtIndex
+    CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex]
+    CFArrayGetValueAtIndex.restype = ctypes.c_void_p
+
+    MTDeviceCreateList = MultitouchSupport.MTDeviceCreateList
+    MTDeviceCreateList.argtypes = []
+    MTDeviceCreateList.restype = CFMutableArrayRef
+
+    class MTPoint(ctypes.Structure):
+        _fields_ = [('x', ctypes.c_float),
+                    ('y', ctypes.c_float)]
+
+    class MTVector(ctypes.Structure):
+        _fields_ = [('position', MTPoint),
+                    ('velocity', MTPoint)]
+
+    class MTData(ctypes.Structure):
+        _fields_ = [
+            ('frame', ctypes.c_int),
+            ('timestamp', ctypes.c_double),
+            ('identifier', ctypes.c_int),
+            # Current state (of unknown meaning).
+            ('state', ctypes.c_int),
+            ('unknown1', ctypes.c_int),
+            ('unknown2', ctypes.c_int),
+            # Normalized position and vector of the touch (0 to 1)
+            ('normalized', MTVector),
+            # The area of the touch.
+            ('size', ctypes.c_float),
+            ('unknown3', ctypes.c_int),
+            # The following three define the ellipsoid of a finger.
+            ('angle', ctypes.c_float),
+            ('major_axis', ctypes.c_float),
+            ('minor_axis', ctypes.c_float),
+            ('unknown4', MTVector),
+            ('unknown5_1', ctypes.c_int),
+            ('unknown5_2', ctypes.c_int),
+            ('unknown6', ctypes.c_float), ]
+
+    MTDataRef = ctypes.POINTER(MTData)
+
+    MTContactCallbackFunction = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int,
+                                                 MTDataRef, ctypes.c_int,
+                                                 ctypes.c_double, ctypes.c_int)
+
+    MTDeviceRef = ctypes.c_void_p
+
+    MTRegisterContactFrameCallback = \
+        MultitouchSupport.MTRegisterContactFrameCallback
+    MTRegisterContactFrameCallback.argtypes = \
+        [MTDeviceRef, MTContactCallbackFunction]
+    MTRegisterContactFrameCallback.restype = None
+
+    MTDeviceStart = MultitouchSupport.MTDeviceStart
+    MTDeviceStart.argtypes = [MTDeviceRef, ctypes.c_int]
+    MTDeviceStart.restype = None
+
+else:
+    MTContactCallbackFunction = lambda x: None
+
+
+class MacMotionEvent(MotionEvent):
+    '''MotionEvent representing a contact point on the touchpad. Supports pos
+    and shape profiles.
+    '''
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'shape')
+
+    def depack(self, args):
+        self.shape = ShapeRect()
+        self.sx, self.sy = args[0], args[1]
+        self.shape.width = args[2]
+        self.shape.height = args[2]
+        super().depack(args)
+
+    def __str__(self):
+        return '<MacMotionEvent id=%d pos=(%f, %f) device=%s>' \
+            % (self.id, self.sx, self.sy, self.device)
+
+
+_instance = None
+
+
+class MacMotionEventProvider(MotionEventProvider):
+
+    def __init__(self, *largs, **kwargs):
+        global _instance
+        if _instance is not None:
+            raise Exception('Only one MacMotionEvent provider is allowed.')
+        _instance = self
+        super(MacMotionEventProvider, self).__init__(*largs, **kwargs)
+
+    def start(self):
+        # global uid
+        self.uid = 0
+        # touches will be per devices
+        self.touches = {}
+        # lock needed to access on uid
+        self.lock = threading.Lock()
+        # event queue to dispatch in main thread
+        self.queue = collections.deque()
+
+        # ok, listing devices, and attach !
+        devices = MultitouchSupport.MTDeviceCreateList()
+        num_devices = CFArrayGetCount(devices)
+        for i in range(num_devices):
+            device = CFArrayGetValueAtIndex(devices, i)
+            # create touch dict for this device
+            data_id = str(device)
+            self.touches[data_id] = {}
+            # start !
+            MTRegisterContactFrameCallback(device, self._mts_callback)
+            MTDeviceStart(device, 0)
+
+    def update(self, dispatch_fn):
+        # dispatch all event from threads
+        try:
+            while True:
+                event_type, touch = self.queue.popleft()
+                dispatch_fn(event_type, touch)
+        except:
+            pass
+
+    def stop(self):
+        # i don't known how to stop it...
+        pass
+
+    @MTContactCallbackFunction
+    def _mts_callback(device, data_ptr, n_fingers, timestamp, frame):
+        global _instance
+        devid = str(device)
+
+        # XXX create live touch, we get one case that
+        # the device announced by macosx don't match the device
+        # in _mts_callback....
+        if devid not in _instance.touches:
+            _instance.touches[devid] = {}
+
+        touches = _instance.touches[devid]
+        actives = []
+
+        for i in range(n_fingers):
+            # get pointer on data
+            data = data_ptr[i]
+
+            # add this touch as an active touch
+            actives.append(data.identifier)
+
+            # extract identifier
+            data_id = data.identifier
+
+            # prepare argument position
+            norm_pos = data.normalized.position
+            args = (norm_pos.x, norm_pos.y, data.size)
+
+            if data_id not in touches:
+                # increment uid
+                _instance.lock.acquire()
+                _instance.uid += 1
+                # create a touch
+                touch = MacMotionEvent(_instance.device, _instance.uid, args)
+                _instance.lock.release()
+                # create event
+                _instance.queue.append(('begin', touch))
+                # store touch
+                touches[data_id] = touch
+            else:
+                touch = touches[data_id]
+                # check if he really moved
+                if data.normalized.position.x == touch.sx and \
+                   data.normalized.position.y == touch.sy:
+                    continue
+                touch.move(args)
+                _instance.queue.append(('update', touch))
+
+        # delete old touchs
+        for tid in list(touches.keys())[:]:
+            if tid not in actives:
+                touch = touches[tid]
+                touch.update_time_end()
+                _instance.queue.append(('end', touch))
+                del touches[tid]
+
+        return 0
+
+
+MotionEventFactory.register('mactouch', MacMotionEventProvider)
diff --git a/kivy/input/providers/mouse.py b/kivy/input/providers/mouse.py
new file mode 100644
index 0000000..624a50e
--- /dev/null
+++ b/kivy/input/providers/mouse.py
@@ -0,0 +1,424 @@
+'''
+Mouse provider implementation
+=============================
+
+On linux systems, the mouse provider can be annoying when used with another
+multitouch provider (hidinput or mtdev). The Mouse can conflict with them: a
+single touch can generate one event from the mouse provider and another
+from the multitouch provider.
+
+To avoid this behavior, you can activate the "disable_on_activity" token in
+the mouse configuration. Then, if any touches are created by another
+provider, the mouse event will be discarded. Add this to your configuration::
+
+    [input]
+    mouse = mouse,disable_on_activity
+
+Using multitouch interaction with the mouse
+-------------------------------------------
+
+.. versionadded:: 1.3.0
+
+By default, the middle and right mouse buttons, as well as a combination of
+ctrl + left mouse button are used for multitouch emulation.
+If you want to use them for other purposes, you can disable this behavior by
+activating the "disable_multitouch" token::
+
+   [input]
+   mouse = mouse,disable_multitouch
+
+.. versionchanged:: 1.9.0
+
+You can now selectively control whether a click initiated as described above
+will emulate multi-touch. If the touch has been initiated in the above manner
+(e.g. right mouse button), a `multitouch_sim` value will be added to the
+touch's profile, and a `multitouch_sim` property will be added to the touch.
+By default, `multitouch_sim` is True and multitouch will be emulated for that
+touch. If, however, `multitouch_on_demand` is added to the config::
+
+   [input]
+   mouse = mouse,multitouch_on_demand
+
+then `multitouch_sim` defaults to `False`. In that case, if `multitouch_sim`
+is set to True before the mouse is released (e.g. in on_touch_down/move), the
+touch will simulate a multi-touch event. For example::
+
+    if 'multitouch_sim' in touch.profile:
+        touch.multitouch_sim = True
+
+.. versionchanged:: 2.1.0
+
+Provider dispatches hover events by listening to properties/events in
+:class:`~kivy.core.window.Window`. Dispatching can be disabled by setting
+:attr:`MouseMotionEventProvider.disable_hover` to ``True`` or by adding
+`disable_hover` in the config::
+
+    [input]
+    mouse = mouse,disable_hover
+
+It's also possible to enable/disable hover events at runtime with
+:attr:`MouseMotionEventProvider.disable_hover` property.
+
+Following is a list of the supported values for the
+:attr:`~kivy.input.motionevent.MotionEvent.profile` property list.
+
+================ ==========================================================
+Profile value    Description
+---------------- ----------------------------------------------------------
+button           Mouse button (one of `left`, `right`, `middle`, `scrollup`
+                 or `scrolldown`). Accessed via the 'button' property.
+pos              2D position. Also reflected in the
+                 :attr:`~kivy.input.motionevent.MotionEvent.x`,
+                 :attr:`~kivy.input.motionevent.MotionEvent.y`
+                 and :attr:`~kivy.input.motionevent.MotionEvent.pos`
+                 properties.
+multitouch_sim   Specifies whether multitouch is simulated or not. Accessed
+                 via the 'multitouch_sim' property.
+================ ==========================================================
+
+'''
+
+__all__ = ('MouseMotionEventProvider', )
+
+from kivy.base import EventLoop
+from collections import deque
+from kivy.logger import Logger
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+
+# late binding
+Color = Ellipse = None
+
+
+class MouseMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        self.multitouch_sim = False
+        super().__init__(*args, **kwargs)
+
+    def depack(self, args):
+        self.sx, self.sy = args[:2]
+        profile = self.profile
+        if self.is_touch:
+            # don't overwrite previous profile
+            if not profile:
+                profile.extend(('pos', 'button'))
+            if len(args) >= 3:
+                self.button = args[2]
+            if len(args) == 4:
+                self.multitouch_sim = args[3]
+                profile.append('multitouch_sim')
+        else:
+            if not profile:
+                profile.append('pos')
+        super().depack(args)
+
+    #
+    # Create automatically touch on the surface.
+    #
+
+    def update_graphics(self, win, create=False):
+        global Color, Ellipse
+        de = self.ud.get('_drawelement', None)
+        if de is None and create:
+            if Color is None:
+                from kivy.graphics import Color, Ellipse
+            with win.canvas.after:
+                de = (
+                    Color(.8, .2, .2, .7),
+                    Ellipse(size=(20, 20), segments=15))
+            self.ud._drawelement = de
+        if de is not None:
+            self.push()
+
+            # use same logic as WindowBase.on_motion() so we get correct
+            # coordinates when _density != 1
+            w, h = win._get_effective_size()
+
+            self.scale_for_screen(w, h, rotation=win.rotation)
+
+            de[1].pos = self.x - 10, self.y - 10
+            self.pop()
+
+    def clear_graphics(self, win):
+        de = self.ud.pop('_drawelement', None)
+        if de is not None:
+            win.canvas.after.remove(de[0])
+            win.canvas.after.remove(de[1])
+
+
+class MouseMotionEventProvider(MotionEventProvider):
+    __handlers__ = {}
+
+    def __init__(self, device, args):
+        super(MouseMotionEventProvider, self).__init__(device, args)
+        self.waiting_event = deque()
+        self.touches = {}
+        self.counter = 0
+        self.current_drag = None
+        self.alt_touch = None
+        self.disable_on_activity = False
+        self.disable_multitouch = False
+        self.multitouch_on_demand = False
+        self.hover_event = None
+        self._disable_hover = False
+        self._running = False
+        # split arguments
+        args = args.split(',')
+        for arg in args:
+            arg = arg.strip()
+            if arg == '':
+                continue
+            elif arg == 'disable_on_activity':
+                self.disable_on_activity = True
+            elif arg == 'disable_multitouch':
+                self.disable_multitouch = True
+            elif arg == 'disable_hover':
+                self.disable_hover = True
+            elif arg == 'multitouch_on_demand':
+                self.multitouch_on_demand = True
+            else:
+                Logger.error('Mouse: unknown parameter <%s>' % arg)
+
+    def _get_disable_hover(self):
+        return self._disable_hover
+
+    def _set_disable_hover(self, value):
+        if self._disable_hover != value:
+            if self._running:
+                if value:
+                    self._stop_hover_events()
+                else:
+                    self._start_hover_events()
+            self._disable_hover = value
+
+    disable_hover = property(_get_disable_hover, _set_disable_hover)
+    '''Disables dispatching of hover events if set to ``True``.
+
+    Hover events are enabled by default (`disable_hover` is ``False``). See
+    module documentation if you want to enable/disable hover events through
+    config file.
+
+    .. versionadded:: 2.1.0
+    '''
+
+    def start(self):
+        '''Start the mouse provider'''
+        if not EventLoop.window:
+            return
+        fbind = EventLoop.window.fbind
+        fbind('on_mouse_down', self.on_mouse_press)
+        fbind('on_mouse_move', self.on_mouse_motion)
+        fbind('on_mouse_up', self.on_mouse_release)
+        fbind('on_rotate', self.update_touch_graphics)
+        fbind('system_size', self.update_touch_graphics)
+        if not self.disable_hover:
+            self._start_hover_events()
+        self._running = True
+
+    def _start_hover_events(self):
+        fbind = EventLoop.window.fbind
+        fbind('mouse_pos', self.begin_or_update_hover_event)
+        fbind('system_size', self.update_hover_event)
+        fbind('on_cursor_enter', self.begin_hover_event)
+        fbind('on_cursor_leave', self.end_hover_event)
+        fbind('on_close', self.end_hover_event)
+        fbind('on_rotate', self.update_hover_event)
+
+    def stop(self):
+        '''Stop the mouse provider'''
+        if not EventLoop.window:
+            return
+        funbind = EventLoop.window.funbind
+        funbind('on_mouse_down', self.on_mouse_press)
+        funbind('on_mouse_move', self.on_mouse_motion)
+        funbind('on_mouse_up', self.on_mouse_release)
+        funbind('on_rotate', self.update_touch_graphics)
+        funbind('system_size', self.update_touch_graphics)
+        if not self.disable_hover:
+            self._stop_hover_events()
+        self._running = False
+
+    def _stop_hover_events(self):
+        funbind = EventLoop.window.funbind
+        funbind('mouse_pos', self.begin_or_update_hover_event)
+        funbind('system_size', self.update_hover_event)
+        funbind('on_cursor_enter', self.begin_hover_event)
+        funbind('on_cursor_leave', self.end_hover_event)
+        funbind('on_close', self.end_hover_event)
+        funbind('on_rotate', self.update_hover_event)
+
+    def test_activity(self):
+        if not self.disable_on_activity:
+            return False
+        # trying to get if we currently have other touch than us
+        # discard touches generated from kinetic
+        for touch in EventLoop.touches:
+            # discard all kinetic touch
+            if touch.__class__.__name__ == 'KineticMotionEvent':
+                continue
+            # not our instance, stop mouse
+            if touch.__class__ != MouseMotionEvent:
+                return True
+        return False
+
+    def find_touch(self, win, x, y):
+        factor = 10. / win.system_size[0]
+        for touch in self.touches.values():
+            if abs(x - touch.sx) < factor and abs(y - touch.sy) < factor:
+                return touch
+        return None
+
+    def create_event_id(self):
+        self.counter += 1
+        return self.device + str(self.counter)
+
+    def create_touch(self, win, nx, ny, is_double_tap, do_graphics, button):
+        event_id = self.create_event_id()
+        args = [nx, ny, button]
+        if do_graphics:
+            args += [not self.multitouch_on_demand]
+        self.current_drag = touch = MouseMotionEvent(
+            self.device, event_id, args,
+            is_touch=True,
+            type_id='touch'
+        )
+        touch.is_double_tap = is_double_tap
+        self.touches[event_id] = touch
+        if do_graphics:
+            # only draw red circle if multitouch is not disabled, and
+            # if the multitouch_on_demand feature is not enable
+            # (because in that case, we wait to see if multitouch_sim
+            # is True or not before doing the multitouch)
+            create_flag = (
+                not self.disable_multitouch
+                and not self.multitouch_on_demand
+            )
+            touch.update_graphics(win, create_flag)
+        self.waiting_event.append(('begin', touch))
+        return touch
+
+    def remove_touch(self, win, touch):
+        if touch.id in self.touches:
+            del self.touches[touch.id]
+            touch.update_time_end()
+            self.waiting_event.append(('end', touch))
+            touch.clear_graphics(win)
+
+    def create_hover(self, win, etype):
+        nx, ny = win.to_normalized_pos(*win.mouse_pos)
+        # Divide by density because it's used by mouse_pos
+        nx /= win._density
+        ny /= win._density
+        args = (nx, ny)
+        hover = self.hover_event
+        if hover:
+            hover.move(args)
+        else:
+            self.hover_event = hover = MouseMotionEvent(
+                self.device,
+                self.create_event_id(),
+                args,
+                type_id='hover'
+            )
+        if etype == 'end':
+            hover.update_time_end()
+            self.hover_event = None
+        self.waiting_event.append((etype, hover))
+
+    def on_mouse_motion(self, win, x, y, modifiers):
+        nx, ny = win.to_normalized_pos(x, y)
+        ny = 1.0 - ny
+        if self.current_drag:
+            touch = self.current_drag
+            touch.move([nx, ny])
+            touch.update_graphics(win)
+            self.waiting_event.append(('update', touch))
+        elif self.alt_touch is not None and 'alt' not in modifiers:
+            # alt just released ?
+            is_double_tap = 'shift' in modifiers
+            self.create_touch(win, nx, ny, is_double_tap, True, [])
+
+    def on_mouse_press(self, win, x, y, button, modifiers):
+        if self.test_activity():
+            return
+        nx, ny = win.to_normalized_pos(x, y)
+        ny = 1.0 - ny
+        found_touch = self.find_touch(win, nx, ny)
+        if found_touch:
+            self.current_drag = found_touch
+        else:
+            is_double_tap = 'shift' in modifiers
+            do_graphics = (
+                not self.disable_multitouch
+                and (button != 'left' or 'ctrl' in modifiers)
+            )
+            touch = self.create_touch(
+                win, nx, ny, is_double_tap, do_graphics, button
+            )
+            if 'alt' in modifiers:
+                self.alt_touch = touch
+                self.current_drag = None
+
+    def on_mouse_release(self, win, x, y, button, modifiers):
+        if button == 'all':
+            # Special case, if button is all,
+            # then remove all the current touches.
+            for touch in list(self.touches.values()):
+                self.remove_touch(win, touch)
+            self.current_drag = None
+        touch = self.current_drag
+        if touch:
+            not_right = button in (
+                'left',
+                'scrollup', 'scrolldown',
+                'scrollleft', 'scrollright'
+            )
+            not_ctrl = 'ctrl' not in modifiers
+            not_multi = (
+                self.disable_multitouch
+                or 'multitouch_sim' not in touch.profile
+                or not touch.multitouch_sim
+            )
+            if not_right and not_ctrl or not_multi:
+                self.remove_touch(win, touch)
+                self.current_drag = None
+            else:
+                touch.update_graphics(win, True)
+        if self.alt_touch:
+            self.remove_touch(win, self.alt_touch)
+            self.alt_touch = None
+
+    def update_touch_graphics(self, win, *args):
+        for touch in self.touches.values():
+            touch.update_graphics(win)
+
+    def begin_or_update_hover_event(self, win, *args):
+        etype = 'update' if self.hover_event else 'begin'
+        self.create_hover(win, etype)
+
+    def begin_hover_event(self, win, *args):
+        if not self.hover_event:
+            self.create_hover(win, 'begin')
+
+    def update_hover_event(self, win, *args):
+        if self.hover_event:
+            self.create_hover(win, 'update')
+
+    def end_hover_event(self, win, *args):
+        if self.hover_event:
+            self.create_hover(win, 'end')
+
+    def update(self, dispatch_fn):
+        '''Update the mouse provider (pop event from the queue)'''
+        try:
+            while True:
+                event = self.waiting_event.popleft()
+                dispatch_fn(*event)
+        except IndexError:
+            pass
+
+
+# registers
+MotionEventFactory.register('mouse', MouseMotionEventProvider)
diff --git a/kivy/input/providers/mtdev.py b/kivy/input/providers/mtdev.py
new file mode 100644
index 0000000..7708689
--- /dev/null
+++ b/kivy/input/providers/mtdev.py
@@ -0,0 +1,383 @@
+'''
+Native support for Multitouch devices on Linux, using libmtdev.
+===============================================================
+
+The Mtdev project is a part of the Ubuntu Maverick multitouch architecture.
+You can read more on http://wiki.ubuntu.com/Multitouch
+
+To configure MTDev, it's preferable to use probesysfs providers.
+Check :py:class:`~kivy.input.providers.probesysfs` for more information.
+
+Otherwise, add this to your configuration::
+
+    [input]
+    # devicename = hidinput,/dev/input/eventXX
+    acert230h = mtdev,/dev/input/event2
+
+.. note::
+    You must have read access to the input event.
+
+You can use a custom range for the X, Y and pressure values.
+On some drivers, the range reported is invalid.
+To fix that, you can add these options to the argument line:
+
+* invert_x : 1 to invert X axis
+* invert_y : 1 to invert Y axis
+* min_position_x : X minimum
+* max_position_x : X maximum
+* min_position_y : Y minimum
+* max_position_y : Y maximum
+* min_pressure : pressure minimum
+* max_pressure : pressure maximum
+* min_touch_major : width shape minimum
+* max_touch_major : width shape maximum
+* min_touch_minor : width shape minimum
+* max_touch_minor : height shape maximum
+* rotation : 0,90,180 or 270 to rotate
+
+An inverted display configuration will look like this::
+
+    [input]
+    # example for inverting touch events
+    display = mtdev,/dev/input/event0,invert_x=1,invert_y=1
+'''
+
+__all__ = ('MTDMotionEventProvider', 'MTDMotionEvent')
+
+import os
+import os.path
+import time
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+
+class MTDMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+
+    def depack(self, args):
+        if 'x' in args:
+            self.sx = args['x']
+        else:
+            self.sx = -1
+        if 'y' in args:
+            self.sy = args['y']
+        else:
+            self.sy = -1
+        self.profile = ['pos']
+        if 'size_w' in args and 'size_h' in args:
+            self.shape = ShapeRect()
+            self.shape.width = args['size_w']
+            self.shape.height = args['size_h']
+            self.profile.append('shape')
+        if 'pressure' in args:
+            self.pressure = args['pressure']
+            self.profile.append('pressure')
+        super().depack(args)
+
+    def __str__(self):
+        i, sx, sy, d = (self.id, self.sx, self.sy, self.device)
+        return '<MTDMotionEvent id=%d pos=(%f, %f) device=%s>' % (i, sx, sy, d)
+
+
+if 'KIVY_DOC' in os.environ:
+
+    # documentation hack
+    MTDMotionEventProvider = None
+
+else:
+    import threading
+    import collections
+    from kivy.lib.mtdev import Device, \
+        MTDEV_TYPE_EV_ABS, MTDEV_CODE_SLOT, MTDEV_CODE_POSITION_X, \
+        MTDEV_CODE_POSITION_Y, MTDEV_CODE_PRESSURE, \
+        MTDEV_CODE_TOUCH_MAJOR, MTDEV_CODE_TOUCH_MINOR, \
+        MTDEV_CODE_TRACKING_ID, MTDEV_ABS_POSITION_X, \
+        MTDEV_ABS_POSITION_Y, MTDEV_ABS_TOUCH_MINOR, \
+        MTDEV_ABS_TOUCH_MAJOR
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+    from kivy.logger import Logger
+
+    class MTDMotionEventProvider(MotionEventProvider):
+
+        options = ('min_position_x', 'max_position_x',
+                   'min_position_y', 'max_position_y',
+                   'min_pressure', 'max_pressure',
+                   'min_touch_major', 'max_touch_major',
+                   'min_touch_minor', 'max_touch_minor',
+                   'invert_x', 'invert_y',
+                   'rotation')
+
+        def __init__(self, device, args):
+            super(MTDMotionEventProvider, self).__init__(device, args)
+            self._device = None
+            self.input_fn = None
+            self.default_ranges = dict()
+
+            # split arguments
+            args = args.split(',')
+            if not args:
+                Logger.error('MTD: No filename pass to MTD configuration')
+                Logger.error('MTD: Use /dev/input/event0 for example')
+                return
+
+            # read filename
+            self.input_fn = args[0]
+            Logger.info('MTD: Read event from <%s>' % self.input_fn)
+
+            # read parameters
+            for arg in args[1:]:
+                if arg == '':
+                    continue
+                arg = arg.split('=')
+
+                # ensure it's a key = value
+                if len(arg) != 2:
+                    err = 'MTD: Bad parameter %s: Not in key=value format' %\
+                        arg
+                    Logger.error(err)
+                    continue
+
+                # ensure the key exist
+                key, value = arg
+                if key not in MTDMotionEventProvider.options:
+                    Logger.error('MTD: unknown %s option' % key)
+                    continue
+
+                # ensure the value
+                try:
+                    self.default_ranges[key] = int(value)
+                except ValueError:
+                    err = 'MTD: invalid value %s for option %s' % (key, value)
+                    Logger.error(err)
+                    continue
+
+                # all good!
+                Logger.info('MTD: Set custom %s to %d' % (key, int(value)))
+
+            if 'rotation' not in self.default_ranges:
+                self.default_ranges['rotation'] = 0
+            elif self.default_ranges['rotation'] not in (0, 90, 180, 270):
+                Logger.error('HIDInput: invalid rotation value ({})'.format(
+                    self.default_ranges['rotation']))
+                self.default_ranges['rotation'] = 0
+
+        def start(self):
+            if self.input_fn is None:
+                return
+            self.uid = 0
+            self.queue = collections.deque()
+            self.thread = threading.Thread(
+                name=self.__class__.__name__,
+                target=self._thread_run,
+                kwargs=dict(
+                    queue=self.queue,
+                    input_fn=self.input_fn,
+                    device=self.device,
+                    default_ranges=self.default_ranges))
+            self.thread.daemon = True
+            self.thread.start()
+
+        def _thread_run(self, **kwargs):
+            input_fn = kwargs.get('input_fn')
+            queue = kwargs.get('queue')
+            device = kwargs.get('device')
+            drs = kwargs.get('default_ranges').get
+            touches = {}
+            touches_sent = []
+            point = {}
+            l_points = {}
+
+            def assign_coord(point, value, invert, coords):
+                cx, cy = coords
+                if invert:
+                    value = 1. - value
+                if rotation == 0:
+                    point[cx] = value
+                elif rotation == 90:
+                    point[cy] = value
+                elif rotation == 180:
+                    point[cx] = 1. - value
+                elif rotation == 270:
+                    point[cy] = 1. - value
+
+            def process(points):
+                for args in points:
+                    # this can happen if we have a touch going on already at
+                    # the start of the app
+                    if 'id' not in args:
+                        continue
+                    tid = args['id']
+                    try:
+                        touch = touches[tid]
+                    except KeyError:
+                        touch = MTDMotionEvent(device, tid, args)
+                        touches[touch.id] = touch
+                    touch.move(args)
+                    action = 'update'
+                    if tid not in touches_sent:
+                        action = 'begin'
+                        touches_sent.append(tid)
+                    if 'delete' in args:
+                        action = 'end'
+                        del args['delete']
+                        del touches[touch.id]
+                        touches_sent.remove(tid)
+                        touch.update_time_end()
+                    queue.append((action, touch))
+
+            def normalize(value, vmin, vmax):
+                try:
+                    return (value - vmin) / float(vmax - vmin)
+                except ZeroDivisionError:  # it's both in py2 and py3
+                    return (value - vmin)
+
+            # open mtdev device
+            _fn = input_fn
+            _slot = 0
+            try:
+                _device = Device(_fn)
+            except OSError as e:
+                if e.errno == 13:  # Permission denied
+                    Logger.warn(
+                        'MTD: Unable to open device "{0}". Please ensure you'
+                        ' have the appropriate permissions.'.format(_fn))
+                    return
+                else:
+                    raise
+            _changes = set()
+
+            # prepare some vars to get limit of some component
+            ab = _device.get_abs(MTDEV_ABS_POSITION_X)
+            range_min_position_x = drs('min_position_x', ab.minimum)
+            range_max_position_x = drs('max_position_x', ab.maximum)
+            Logger.info('MTD: <%s> range position X is %d - %d' %
+                        (_fn, range_min_position_x, range_max_position_x))
+
+            ab = _device.get_abs(MTDEV_ABS_POSITION_Y)
+            range_min_position_y = drs('min_position_y', ab.minimum)
+            range_max_position_y = drs('max_position_y', ab.maximum)
+            Logger.info('MTD: <%s> range position Y is %d - %d' %
+                        (_fn, range_min_position_y, range_max_position_y))
+
+            ab = _device.get_abs(MTDEV_ABS_TOUCH_MAJOR)
+            range_min_major = drs('min_touch_major', ab.minimum)
+            range_max_major = drs('max_touch_major', ab.maximum)
+            Logger.info('MTD: <%s> range touch major is %d - %d' %
+                        (_fn, range_min_major, range_max_major))
+
+            ab = _device.get_abs(MTDEV_ABS_TOUCH_MINOR)
+            range_min_minor = drs('min_touch_minor', ab.minimum)
+            range_max_minor = drs('max_touch_minor', ab.maximum)
+            Logger.info('MTD: <%s> range touch minor is %d - %d' %
+                        (_fn, range_min_minor, range_max_minor))
+
+            range_min_pressure = drs('min_pressure', 0)
+            range_max_pressure = drs('max_pressure', 255)
+            Logger.info('MTD: <%s> range pressure is %d - %d' %
+                        (_fn, range_min_pressure, range_max_pressure))
+
+            invert_x = int(bool(drs('invert_x', 0)))
+            invert_y = int(bool(drs('invert_y', 0)))
+            Logger.info('MTD: <%s> axes invertion: X is %d, Y is %d' %
+                        (_fn, invert_x, invert_y))
+
+            rotation = drs('rotation', 0)
+            Logger.info('MTD: <%s> rotation set to %d' %
+                        (_fn, rotation))
+            failures = 0
+            while _device:
+                # if device have disconnected lets try to connect
+                if failures > 1000:
+                    Logger.info('MTD: <%s> input device disconnected' % _fn)
+                    while not os.path.exists(_fn):
+                        time.sleep(0.05)
+                    # input device is back online let's recreate device
+                    _device.close()
+                    _device = Device(_fn)
+                    Logger.info('MTD: <%s> input device reconnected' % _fn)
+                    failures = 0
+                    continue
+
+                # idle as much as we can.
+                while _device.idle(1000):
+                    continue
+
+                # got data, read all without redoing idle
+                while True:
+                    data = _device.get()
+                    if data is None:
+                        failures += 1
+                        break
+
+                    failures = 0
+
+                    # set the working slot
+                    if data.type == MTDEV_TYPE_EV_ABS and \
+                       data.code == MTDEV_CODE_SLOT:
+                        _slot = data.value
+                        continue
+
+                    # fill the slot
+                    if not (_slot in l_points):
+                        l_points[_slot] = dict()
+                    point = l_points[_slot]
+                    ev_value = data.value
+                    ev_code = data.code
+                    if ev_code == MTDEV_CODE_POSITION_X:
+                        val = normalize(ev_value,
+                                        range_min_position_x,
+                                        range_max_position_x)
+                        assign_coord(point, val, invert_x, 'xy')
+                    elif ev_code == MTDEV_CODE_POSITION_Y:
+                        val = 1. - normalize(ev_value,
+                                             range_min_position_y,
+                                             range_max_position_y)
+                        assign_coord(point, val, invert_y, 'yx')
+                    elif ev_code == MTDEV_CODE_PRESSURE:
+                        point['pressure'] = normalize(ev_value,
+                                                      range_min_pressure,
+                                                      range_max_pressure)
+                    elif ev_code == MTDEV_CODE_TOUCH_MAJOR:
+                        point['size_w'] = normalize(ev_value,
+                                                    range_min_major,
+                                                    range_max_major)
+                    elif ev_code == MTDEV_CODE_TOUCH_MINOR:
+                        point['size_h'] = normalize(ev_value,
+                                                    range_min_minor,
+                                                    range_max_minor)
+                    elif ev_code == MTDEV_CODE_TRACKING_ID:
+                        if ev_value == -1:
+                            point['delete'] = True
+                            # force process of changes here, as the slot can be
+                            # reused.
+                            _changes.add(_slot)
+                            process([l_points[x] for x in _changes])
+                            _changes.clear()
+                            continue
+                        else:
+                            point['id'] = ev_value
+                    else:
+                        # unrecognized command, ignore.
+                        continue
+                    _changes.add(_slot)
+
+                # push all changes
+                if _changes:
+                    process([l_points[x] for x in _changes])
+                    _changes.clear()
+
+        def update(self, dispatch_fn):
+            # dispatch all event from threads
+            try:
+                while True:
+                    event_type, touch = self.queue.popleft()
+                    dispatch_fn(event_type, touch)
+            except:
+                pass
+
+    MotionEventFactory.register('mtdev', MTDMotionEventProvider)
diff --git a/kivy/input/providers/probesysfs.py b/kivy/input/providers/probesysfs.py
new file mode 100644
index 0000000..ff0941f
--- /dev/null
+++ b/kivy/input/providers/probesysfs.py
@@ -0,0 +1,254 @@
+'''
+Auto Create Input Provider Config Entry for Available MT Hardware (linux only).
+===============================================================================
+
+Thanks to Marc Tardif for the probing code, taken from scan-for-mt-device.
+
+The device discovery is done by this provider. However, the reading of
+input can be performed by other providers like: hidinput, mtdev and
+linuxwacom. mtdev is used prior to other providers. For more
+information about mtdev, check :py:class:`~kivy.input.providers.mtdev`.
+
+Here is an example of auto creation::
+
+    [input]
+    # using mtdev
+    device_%(name)s = probesysfs,provider=mtdev
+    # using hidinput
+    device_%(name)s = probesysfs,provider=hidinput
+    # using mtdev with a match on name
+    device_%(name)s = probesysfs,provider=mtdev,match=acer
+
+    # using hidinput with custom parameters to hidinput (all on one line)
+    %(name)s = probesysfs,
+        provider=hidinput,param=min_pressure=1,param=max_pressure=99
+
+    # you can also match your wacom touchscreen
+    touch = probesysfs,match=E3 Finger,provider=linuxwacom,
+        select_all=1,param=mode=touch
+    # and your wacom pen
+    pen = probesysfs,match=E3 Pen,provider=linuxwacom,
+        select_all=1,param=mode=pen
+
+By default, ProbeSysfs module will enumerate hardware from the /sys/class/input
+device, and configure hardware with ABS_MT_POSITION_X capability. But for
+example, the wacom screen doesn't support this capability. You can prevent this
+behavior by putting select_all=1 in your config line. Add use_mouse=1 to also
+include touchscreen hardware that offers core pointer functionality.
+'''
+
+__all__ = ('ProbeSysfsHardwareProbe', )
+
+import os
+from os.path import sep
+
+if 'KIVY_DOC' in os.environ:
+
+    ProbeSysfsHardwareProbe = None
+
+else:
+    import ctypes
+    from re import match, IGNORECASE
+    from glob import glob
+    from subprocess import Popen, PIPE
+    from kivy.logger import Logger
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.providers.mouse import MouseMotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+    from kivy.config import _is_rpi
+
+    EventLoop = None
+
+    # See linux/input.h
+    ABS_MT_POSITION_X = 0x35
+
+    _cache_input = None
+    _cache_xinput = None
+
+    class Input(object):
+
+        def __init__(self, path):
+            query_xinput()
+            self.path = path
+
+        @property
+        def device(self):
+            base = os.path.basename(self.path)
+            return os.path.join("/dev", "input", base)
+
+        @property
+        def name(self):
+            path = os.path.join(self.path, "device", "name")
+            return read_line(path)
+
+        def get_capabilities(self):
+            path = os.path.join(self.path, "device", "capabilities", "abs")
+            line = "0"
+            try:
+                line = read_line(path)
+            except (IOError, OSError):
+                return []
+
+            capabilities = []
+            long_bit = ctypes.sizeof(ctypes.c_long) * 8
+            for i, word in enumerate(line.split(" ")):
+                word = int(word, 16)
+                subcapabilities = [bool(word & 1 << i)
+                                   for i in range(long_bit)]
+                capabilities[:0] = subcapabilities
+
+            return capabilities
+
+        def has_capability(self, capability):
+            capabilities = self.get_capabilities()
+            return len(capabilities) > capability and capabilities[capability]
+
+        @property
+        def is_mouse(self):
+            return self.device in _cache_xinput
+
+    def getout(*args):
+        try:
+            return Popen(args, stdout=PIPE).communicate()[0]
+        except OSError:
+            return ''
+
+    def query_xinput():
+        global _cache_xinput
+        if _cache_xinput is None:
+            _cache_xinput = []
+            devids = getout('xinput', '--list', '--id-only')
+            for did in devids.splitlines():
+                devprops = getout('xinput', '--list-props', did)
+                evpath = None
+                for prop in devprops.splitlines():
+                    prop = prop.strip()
+                    if (prop.startswith(b'Device Enabled') and
+                            prop.endswith(b'0')):
+                        evpath = None
+                        break
+                    if prop.startswith(b'Device Node'):
+                        try:
+                            evpath = prop.split('"')[1]
+                        except Exception:
+                            evpath = None
+                if evpath:
+                    _cache_xinput.append(evpath)
+
+    def get_inputs(path):
+        global _cache_input
+        if _cache_input is None:
+            event_glob = os.path.join(path, "event*")
+            _cache_input = [Input(x) for x in glob(event_glob)]
+        return _cache_input
+
+    def read_line(path):
+        f = open(path)
+        try:
+            return f.readline().strip()
+        finally:
+            f.close()
+
+    class ProbeSysfsHardwareProbe(MotionEventProvider):
+
+        def __new__(self, device, args):
+            # hack to not return an instance of this provider.
+            # :)
+            instance = super(ProbeSysfsHardwareProbe, self).__new__(self)
+            instance.__init__(device, args)
+
+        def __init__(self, device, args):
+            super(ProbeSysfsHardwareProbe, self).__init__(device, args)
+            self.provider = 'mtdev'
+            self.match = None
+            self.input_path = '/sys/class/input'
+            self.select_all = True if _is_rpi else False
+            self.use_mouse = False
+            self.use_regex = False
+            self.args = []
+
+            args = args.split(',')
+            for arg in args:
+                if arg == '':
+                    continue
+                arg = arg.split('=', 1)
+                # ensure it's a key = value
+                if len(arg) != 2:
+                    Logger.error('ProbeSysfs: invalid parameters %s, not'
+                                 ' key=value format' % arg)
+                    continue
+
+                key, value = arg
+                if key == 'match':
+                    self.match = value
+                elif key == 'provider':
+                    self.provider = value
+                elif key == 'use_regex':
+                    self.use_regex = bool(int(value))
+                elif key == 'select_all':
+                    self.select_all = bool(int(value))
+                elif key == 'use_mouse':
+                    self.use_mouse = bool(int(value))
+                elif key == 'param':
+                    self.args.append(value)
+                else:
+                    Logger.error('ProbeSysfs: unknown %s option' % key)
+                    continue
+
+            self.probe()
+
+        def should_use_mouse(self):
+            return (self.use_mouse or
+                    not any(p for p in EventLoop.input_providers
+                            if isinstance(p, MouseMotionEventProvider)))
+
+        def probe(self):
+            global EventLoop
+            from kivy.base import EventLoop
+
+            inputs = get_inputs(self.input_path)
+            Logger.debug('ProbeSysfs: using probesysfs!')
+
+            use_mouse = self.should_use_mouse()
+
+            if not self.select_all:
+                inputs = [x for x in inputs if
+                          x.has_capability(ABS_MT_POSITION_X) and
+                          (use_mouse or not x.is_mouse)]
+            for device in inputs:
+                Logger.debug('ProbeSysfs: found device: %s at %s' % (
+                    device.name, device.device))
+
+                # must ignore ?
+                if self.match:
+                    if self.use_regex:
+                        if not match(self.match, device.name, IGNORECASE):
+                            Logger.debug('ProbeSysfs: device not match the'
+                                         ' rule in config, ignoring.')
+                            continue
+                    else:
+                        if self.match not in device.name:
+                            continue
+
+                Logger.info('ProbeSysfs: device match: %s' % device.device)
+
+                d = device.device
+                devicename = self.device % dict(name=d.split(sep)[-1])
+
+                provider = MotionEventFactory.get(self.provider)
+                if provider is None:
+                    Logger.info('ProbeSysfs: Unable to find provider %s' %
+                                self.provider)
+                    Logger.info('ProbeSysfs: fallback on hidinput')
+                    provider = MotionEventFactory.get('hidinput')
+                if provider is None:
+                    Logger.critical('ProbeSysfs: no input provider found'
+                                    ' to handle this device !')
+                    continue
+
+                instance = provider(devicename, '%s,%s' % (
+                    device.device, ','.join(self.args)))
+                if instance:
+                    EventLoop.add_input_provider(instance)
+
+    MotionEventFactory.register('probesysfs', ProbeSysfsHardwareProbe)
diff --git a/kivy/input/providers/tuio.py b/kivy/input/providers/tuio.py
new file mode 100644
index 0000000..84fcb1d
--- /dev/null
+++ b/kivy/input/providers/tuio.py
@@ -0,0 +1,326 @@
+'''
+TUIO Input Provider
+===================
+
+TUIO is the de facto standard network protocol for the transmission of
+touch and fiducial information between a server and a client. To learn
+more about TUIO (which is itself based on the OSC protocol), please
+refer to http://tuio.org -- The specification should be of special
+interest.
+
+Configure a TUIO provider in the config.ini
+-------------------------------------------
+
+The TUIO provider can be configured in the configuration file in the
+``[input]`` section::
+
+    [input]
+    # name = tuio,<ip>:<port>
+    multitouchtable = tuio,192.168.0.1:3333
+
+Configure a TUIO provider in the App
+------------------------------------
+
+You must add the provider before your application is run, like this::
+
+    from kivy.app import App
+    from kivy.config import Config
+
+    class TestApp(App):
+        def build(self):
+            Config.set('input', 'multitouchscreen1', 'tuio,0.0.0.0:3333')
+            # You can also add a second TUIO listener
+            # Config.set('input', 'source2', 'tuio,0.0.0.0:3334')
+            # Then do the usual things
+            # ...
+            return
+'''
+
+__all__ = ('TuioMotionEventProvider', 'Tuio2dCurMotionEvent',
+           'Tuio2dObjMotionEvent')
+
+from kivy.logger import Logger
+
+from functools import partial
+from collections import deque
+from kivy.input.provider import MotionEventProvider
+from kivy.input.factory import MotionEventFactory
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+
+class TuioMotionEventProvider(MotionEventProvider):
+    '''The TUIO provider listens to a socket and handles some of the incoming
+    OSC messages:
+
+        * /tuio/2Dcur
+        * /tuio/2Dobj
+
+    You can easily extend the provider to handle new TUIO paths like so::
+
+        # Create a class to handle the new TUIO type/path
+        # Replace NEWPATH with the pathname you want to handle
+        class TuioNEWPATHMotionEvent(MotionEvent):
+
+            def depack(self, args):
+                # In this method, implement 'unpacking' for the received
+                # arguments. you basically translate from TUIO args to Kivy
+                # MotionEvent variables. If all you receive are x and y
+                # values, you can do it like this:
+                if len(args) == 2:
+                    self.sx, self.sy = args
+                    self.profile = ('pos', )
+                self.sy = 1 - self.sy
+                super().depack(args)
+
+        # Register it with the TUIO MotionEvent provider.
+        # You obviously need to replace the PATH placeholders appropriately.
+        TuioMotionEventProvider.register('/tuio/PATH', TuioNEWPATHMotionEvent)
+
+    .. note::
+
+        The class name is of no technical importance. Your class will be
+        associated with the path that you pass to the ``register()``
+        function. To keep things simple, you should name your class after the
+        path that it handles, though.
+    '''
+
+    __handlers__ = {}
+
+    def __init__(self, device, args):
+        super().__init__(device, args)
+        args = args.split(',')
+        if len(args) == 0:
+            Logger.error('Tuio: Invalid configuration for TUIO provider')
+            Logger.error('Tuio: Format must be ip:port (eg. 127.0.0.1:3333)')
+            err = 'Tuio: Current configuration is <%s>' % (str(','.join(args)))
+            Logger.error(err)
+            return
+        ipport = args[0].split(':')
+        if len(ipport) != 2:
+            Logger.error('Tuio: Invalid configuration for TUIO provider')
+            Logger.error('Tuio: Format must be ip:port (eg. 127.0.0.1:3333)')
+            err = 'Tuio: Current configuration is <%s>' % (str(','.join(args)))
+            Logger.error(err)
+            return
+        self.ip, self.port = args[0].split(':')
+        self.port = int(self.port)
+        self.handlers = {}
+        self.oscid = None
+        self.tuio_event_q = deque()
+        self.touches = {}
+
+    @staticmethod
+    def register(oscpath, classname):
+        '''Register a new path to handle in TUIO provider'''
+        TuioMotionEventProvider.__handlers__[oscpath] = classname
+
+    @staticmethod
+    def unregister(oscpath, classname):
+        '''Unregister a path to stop handling it in the TUIO provider'''
+        if oscpath in TuioMotionEventProvider.__handlers__:
+            del TuioMotionEventProvider.__handlers__[oscpath]
+
+    @staticmethod
+    def create(oscpath, **kwargs):
+        '''Create a touch event from a TUIO path'''
+        if oscpath not in TuioMotionEventProvider.__handlers__:
+            raise Exception('Unknown %s touch path' % oscpath)
+        return TuioMotionEventProvider.__handlers__[oscpath](**kwargs)
+
+    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))
+
+    def stop(self):
+        '''Stop the TUIO provider'''
+        self.oscid.stop_all()
+
+    def update(self, dispatch_fn):
+        '''Update the TUIO provider (pop events from the queue)'''
+
+        # read the Queue with event
+        while True:
+            try:
+                value = self.tuio_event_q.pop()
+            except IndexError:
+                # queue is empty, we're done for now
+                return
+            self._update(dispatch_fn, value)
+
+    def _osc_tuio_cb(self, oscpath, address, *args):
+        self.tuio_event_q.appendleft([oscpath, address, args])
+
+    def _update(self, dispatch_fn, value):
+        oscpath, command, args = value
+
+        # verify commands
+        if command not in [b'alive', b'set']:
+            return
+
+        # move or create a new touch
+        if command == b'set':
+            id = args[0]
+            if id not in self.touches[oscpath]:
+                # new touch
+                touch = TuioMotionEventProvider.__handlers__[oscpath](
+                    self.device, id, args[1:])
+                self.touches[oscpath][id] = touch
+                dispatch_fn('begin', touch)
+            else:
+                # update a current touch
+                touch = self.touches[oscpath][id]
+                touch.move(args[1:])
+                dispatch_fn('update', touch)
+
+        # alive event, check for deleted touch
+        if command == b'alive':
+            alives = args
+            to_delete = []
+            for id in self.touches[oscpath]:
+                if id not in alives:
+                    # touch up
+                    touch = self.touches[oscpath][id]
+                    if touch not in to_delete:
+                        to_delete.append(touch)
+
+            for touch in to_delete:
+                dispatch_fn('end', touch)
+                del self.touches[oscpath][touch.id]
+
+
+class TuioMotionEvent(MotionEvent):
+    '''Abstraction for TUIO touches/fiducials.
+
+    Depending on the tracking software you use (e.g. Movid, CCV, etc.) and its
+    TUIO implementation, the TuioMotionEvent object can support multiple
+    profiles such as:
+
+        * Fiducial ID: profile name 'markerid', attribute ``.fid``
+        * Position: profile name 'pos', attributes ``.x``, ``.y``
+        * Angle: profile name 'angle', attribute ``.a``
+        * Velocity vector: profile name 'mov', attributes ``.X``, ``.Y``
+        * Rotation velocity: profile name 'rot', attribute ``.A``
+        * Motion acceleration: profile name 'motacc', attribute ``.m``
+        * Rotation acceleration: profile name 'rotacc', attribute ``.r``
+    '''
+    __attrs__ = ('a', 'b', 'c', 'X', 'Y', 'Z', 'A', 'B', 'C', 'm', 'r')
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        # Default argument for TUIO touches
+        self.a = 0.0
+        self.b = 0.0
+        self.c = 0.0
+        self.X = 0.0
+        self.Y = 0.0
+        self.Z = 0.0
+        self.A = 0.0
+        self.B = 0.0
+        self.C = 0.0
+        self.m = 0.0
+        self.r = 0.0
+
+    angle = property(lambda self: self.a)
+    mot_accel = property(lambda self: self.m)
+    rot_accel = property(lambda self: self.r)
+    xmot = property(lambda self: self.X)
+    ymot = property(lambda self: self.Y)
+    zmot = property(lambda self: self.Z)
+
+
+class Tuio2dCurMotionEvent(TuioMotionEvent):
+    '''A 2dCur TUIO touch.'''
+
+    def depack(self, args):
+        if len(args) < 5:
+            self.sx, self.sy = list(map(float, args[0:2]))
+            self.profile = ('pos', )
+        elif len(args) == 5:
+            self.sx, self.sy, self.X, self.Y, self.m = list(map(float,
+                                                                args[0:5]))
+            self.Y = -self.Y
+            self.profile = ('pos', 'mov', 'motacc')
+        else:
+            self.sx, self.sy, self.X, self.Y = list(map(float, args[0:4]))
+            self.m, width, height = list(map(float, args[4:7]))
+            self.Y = -self.Y
+            self.profile = ('pos', 'mov', 'motacc', 'shape')
+            if self.shape is None:
+                self.shape = ShapeRect()
+            self.shape.width = width
+            self.shape.height = height
+        self.sy = 1 - self.sy
+        super().depack(args)
+
+
+class Tuio2dObjMotionEvent(TuioMotionEvent):
+    '''A 2dObj TUIO object.
+    '''
+
+    def depack(self, args):
+        if len(args) < 5:
+            self.sx, self.sy = args[0:2]
+            self.profile = ('pos', )
+        elif len(args) == 9:
+            self.fid, self.sx, self.sy, self.a, self.X, self.Y = args[:6]
+            self.A, self.m, self.r = args[6:9]
+            self.Y = -self.Y
+            self.profile = ('markerid', 'pos', 'angle', 'mov', 'rot',
+                            'motacc', 'rotacc')
+        else:
+            self.fid, self.sx, self.sy, self.a, self.X, self.Y = args[:6]
+            self.A, self.m, self.r, width, height = args[6:11]
+            self.Y = -self.Y
+            self.profile = ('markerid', 'pos', 'angle', 'mov', 'rot', 'rotacc',
+                            'acc', 'shape')
+            if self.shape is None:
+                self.shape = ShapeRect()
+                self.shape.width = width
+                self.shape.height = height
+        self.sy = 1 - self.sy
+        super().depack(args)
+
+
+class Tuio2dBlbMotionEvent(TuioMotionEvent):
+    '''A 2dBlb TUIO object.
+    # FIXME 3d shape are not supported
+    /tuio/2Dobj set s i x y a       X Y A m r
+    /tuio/2Dblb set s   x y a w h f X Y A m r
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'angle', 'mov', 'rot', 'rotacc', 'acc', 'shape')
+
+    def depack(self, args):
+        self.sx, self.sy, self.a, self.X, self.Y, sw, sh, sd, \
+            self.A, self.m, self.r = args
+        self.Y = -self.Y
+        if self.shape is None:
+            self.shape = ShapeRect()
+            self.shape.width = sw
+            self.shape.height = sh
+        self.sy = 1 - self.sy
+        super().depack(args)
+
+
+# registers
+TuioMotionEventProvider.register(b'/tuio/2Dcur', Tuio2dCurMotionEvent)
+TuioMotionEventProvider.register(b'/tuio/2Dobj', Tuio2dObjMotionEvent)
+TuioMotionEventProvider.register(b'/tuio/2Dblb', Tuio2dBlbMotionEvent)
+MotionEventFactory.register('tuio', TuioMotionEventProvider)
diff --git a/kivy/input/providers/wm_common.py b/kivy/input/providers/wm_common.py
new file mode 100644
index 0000000..095f6d5
--- /dev/null
+++ b/kivy/input/providers/wm_common.py
@@ -0,0 +1,162 @@
+'''
+Common definitions for a Windows provider
+=========================================
+
+This file provides common definitions for constants used by WM_Touch / WM_Pen.
+'''
+import os
+
+WM_MOUSEFIRST = 512
+WM_MOUSEMOVE = 512
+WM_LBUTTONDOWN = 513
+WM_LBUTTONUP = 514
+WM_LBUTTONDBLCLK = 515
+WM_RBUTTONDOWN = 516
+WM_RBUTTONUP = 517
+WM_RBUTTONDBLCLK = 518
+WM_MBUTTONDOWN = 519
+WM_MBUTTONUP = 520
+WM_MBUTTONDBLCLK = 521
+WM_MOUSEWHEEL = 522
+WM_MOUSELAST = 522
+WM_DPICHANGED = 736
+WM_GETDPISCALEDSIZE = 740
+WM_NCCALCSIZE = 131
+
+WM_TOUCH = 576
+TOUCHEVENTF_MOVE = 1
+TOUCHEVENTF_DOWN = 2
+TOUCHEVENTF_UP = 4
+
+PEN_OR_TOUCH_SIGNATURE = 0xFF515700
+PEN_OR_TOUCH_MASK = 0xFFFFFF00
+PEN_EVENT_TOUCH_MASK = 0x80
+
+SM_CYCAPTION = 4
+
+WM_TABLET_QUERYSYSTEMGESTURE = 0x000002CC
+TABLET_DISABLE_PRESSANDHOLD = 0x00000001
+TABLET_DISABLE_PENTAPFEEDBACK = 0x00000008
+TABLET_DISABLE_PENBARRELFEEDBACK = 0x00000010
+TABLET_DISABLE_TOUCHUIFORCEON = 0x00000100
+TABLET_DISABLE_TOUCHUIFORCEOFF = 0x00000200
+TABLET_DISABLE_TOUCHSWITCH = 0x00008000
+TABLET_DISABLE_FLICKS = 0x00010000
+TABLET_ENABLE_FLICKSONCONTEXT = 0x00020000
+TABLET_ENABLE_FLICKLEARNINGMODE = 0x00040000
+TABLET_DISABLE_SMOOTHSCROLLING = 0x00080000
+TABLET_DISABLE_FLICKFALLBACKKEYS = 0x00100000
+GWL_WNDPROC = -4
+
+
+QUERYSYSTEMGESTURE_WNDPROC = (
+    TABLET_DISABLE_PRESSANDHOLD |
+    TABLET_DISABLE_PENTAPFEEDBACK |
+    TABLET_DISABLE_PENBARRELFEEDBACK |
+    TABLET_DISABLE_SMOOTHSCROLLING |
+    TABLET_DISABLE_FLICKFALLBACKKEYS |
+    TABLET_DISABLE_TOUCHSWITCH |
+    TABLET_DISABLE_FLICKS)
+
+if 'KIVY_DOC' not in os.environ:
+    from ctypes.wintypes import (ULONG, HANDLE, DWORD, LONG, UINT,
+                                 WPARAM, LPARAM, BOOL, HWND, POINT,
+                                 RECT as RECT_BASE)
+    from ctypes import (windll, WINFUNCTYPE, POINTER,
+                        c_int, c_longlong, c_void_p, Structure,
+                        sizeof, byref, cast)
+
+    class RECT(RECT_BASE):
+        x = property(lambda self: self.left)
+        y = property(lambda self: self.top)
+        w = property(lambda self: self.right - self.left)
+        h = property(lambda self: self.bottom - self.top)
+
+    # check availability of RegisterTouchWindow
+    if not hasattr(windll.user32, 'RegisterTouchWindow'):
+        raise Exception('Unsupported Window version')
+
+    LRESULT = LPARAM
+    WNDPROC = WINFUNCTYPE(LRESULT, HWND, UINT, WPARAM, LPARAM)
+
+    class TOUCHINPUT(Structure):
+        _fields_ = [
+            ('x', LONG),
+            ('y', LONG),
+            ('pSource', HANDLE),
+            ('id', DWORD),
+            ('flags', DWORD),
+            ('mask', DWORD),
+            ('time', DWORD),
+            ('extraInfo', POINTER(ULONG)),
+            ('size_x', DWORD),
+            ('size_y', DWORD)]
+
+        def size(self):
+            return (self.size_x, self.size_y)
+
+        def screen_x(self):
+            return self.x / 100.0
+
+        def screen_y(self):
+            return self.y / 100.0
+
+        def _event_type(self):
+            if self.flags & TOUCHEVENTF_MOVE:
+                return 'update'
+            if self.flags & TOUCHEVENTF_DOWN:
+                return 'begin'
+            if self.flags & TOUCHEVENTF_UP:
+                return 'end'
+        event_type = property(_event_type)
+
+    def SetWindowLong_WndProc_wrapper_generator(func):
+        def _closure(hWnd, wndProc):
+            oldAddr = func(hWnd, GWL_WNDPROC, cast(wndProc, c_void_p).value)
+            return cast(c_void_p(oldAddr), WNDPROC)
+
+        return _closure
+
+    try:
+        LONG_PTR = c_longlong
+        windll.user32.SetWindowLongPtrW.restype = LONG_PTR
+        windll.user32.SetWindowLongPtrW.argtypes = [HWND, c_int, LONG_PTR]
+        SetWindowLong_WndProc_wrapper = \
+            SetWindowLong_WndProc_wrapper_generator(
+                windll.user32.SetWindowLongPtrW)
+    except AttributeError:
+        windll.user32.SetWindowLongW.restype = LONG
+        windll.user32.SetWindowLongW.argtypes = [HWND, c_int, LONG]
+        SetWindowLong_WndProc_wrapper = \
+            SetWindowLong_WndProc_wrapper_generator(
+                windll.user32.SetWindowLongW)
+
+    windll.user32.GetMessageExtraInfo.restype = LPARAM
+    windll.user32.GetMessageExtraInfo.argtypes = []
+    windll.user32.GetClientRect.restype = BOOL
+    windll.user32.GetClientRect.argtypes = [HANDLE, POINTER(RECT_BASE)]
+    windll.user32.GetWindowRect.restype = BOOL
+    windll.user32.GetWindowRect.argtypes = [HANDLE, POINTER(RECT_BASE)]
+    windll.user32.CallWindowProcW.restype = LRESULT
+    windll.user32.CallWindowProcW.argtypes = [WNDPROC, HWND, UINT, WPARAM,
+                                              LPARAM]
+    windll.user32.GetActiveWindow.restype = HWND
+    windll.user32.GetActiveWindow.argtypes = []
+    windll.user32.RegisterTouchWindow.restype = BOOL
+    windll.user32.RegisterTouchWindow.argtypes = [HWND, ULONG]
+    windll.user32.UnregisterTouchWindow.restype = BOOL
+    windll.user32.UnregisterTouchWindow.argtypes = [HWND]
+    windll.user32.GetTouchInputInfo.restype = BOOL
+    windll.user32.GetTouchInputInfo.argtypes = [HANDLE, UINT,
+                                                POINTER(TOUCHINPUT), c_int]
+    windll.user32.GetSystemMetrics.restype = c_int
+    windll.user32.GetSystemMetrics.argtypes = [c_int]
+
+    windll.user32.ClientToScreen.restype = BOOL
+    windll.user32.ClientToScreen.argtypes = [HWND, POINTER(POINT)]
+
+    try:
+        windll.user32.GetDpiForWindow.restype = UINT
+        windll.user32.GetDpiForWindow.argtypes = [HWND]
+    except AttributeError:
+        pass
diff --git a/kivy/input/providers/wm_pen.py b/kivy/input/providers/wm_pen.py
new file mode 100644
index 0000000..f58b783
--- /dev/null
+++ b/kivy/input/providers/wm_pen.py
@@ -0,0 +1,121 @@
+'''
+Support for WM_PEN messages (Windows platform)
+==============================================
+'''
+
+__all__ = ('WM_PenProvider', 'WM_Pen')
+
+import os
+from kivy.input.providers.wm_common import RECT, PEN_OR_TOUCH_MASK, \
+    PEN_OR_TOUCH_SIGNATURE, PEN_EVENT_TOUCH_MASK, WM_LBUTTONDOWN, \
+    WM_MOUSEMOVE, WM_LBUTTONUP, WM_TABLET_QUERYSYSTEMGESTURE, \
+    QUERYSYSTEMGESTURE_WNDPROC, WNDPROC, SetWindowLong_WndProc_wrapper
+from kivy.input.motionevent import MotionEvent
+
+
+class WM_Pen(MotionEvent):
+    '''MotionEvent representing the WM_Pen event. Supports the pos profile.'''
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ['pos']
+
+    def depack(self, args):
+        self.sx, self.sy = args[0], args[1]
+        super().depack(args)
+
+    def __str__(self):
+        i, u, s, d = (self.id, self.uid, str(self.spos), self.device)
+        return '<WMPen id:%d uid:%d pos:%s device:%s>' % (i, u, s, d)
+
+
+if 'KIVY_DOC' in os.environ:
+    # documentation hack
+    WM_PenProvider = None
+
+else:
+    from collections import deque
+    from ctypes import windll, byref, c_int16, c_int
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+
+    win_rect = RECT()
+
+    class WM_PenProvider(MotionEventProvider):
+
+        def _is_pen_message(self, msg):
+            info = windll.user32.GetMessageExtraInfo()
+            # It's a touch or a pen
+            if (info & PEN_OR_TOUCH_MASK) == PEN_OR_TOUCH_SIGNATURE:
+                if not info & PEN_EVENT_TOUCH_MASK:
+                    return True
+
+        def _pen_handler(self, msg, wParam, lParam):
+            if msg not in (WM_LBUTTONDOWN, WM_MOUSEMOVE, WM_LBUTTONUP):
+                return
+
+            windll.user32.GetClientRect(self.hwnd, byref(win_rect))
+            x = c_int16(lParam & 0xffff).value / float(win_rect.w)
+            y = c_int16(lParam >> 16).value / float(win_rect.h)
+            y = abs(1.0 - y)
+
+            if msg == WM_LBUTTONDOWN:
+                self.pen_events.appendleft(('begin', x, y))
+                self.pen_status = True
+
+            if msg == WM_MOUSEMOVE and self.pen_status:
+                self.pen_events.appendleft(('update', x, y))
+
+            if msg == WM_LBUTTONUP:
+                self.pen_events.appendleft(('end', x, y))
+                self.pen_status = False
+
+        def _pen_wndProc(self, hwnd, msg, wParam, lParam):
+            if msg == WM_TABLET_QUERYSYSTEMGESTURE:
+                return QUERYSYSTEMGESTURE_WNDPROC
+            if self._is_pen_message(msg):
+                self._pen_handler(msg, wParam, lParam)
+                return 1
+            else:
+                return windll.user32.CallWindowProcW(self.old_windProc,
+                                                     hwnd, msg, wParam, lParam)
+
+        def start(self):
+            self.uid = 0
+            self.pen = None
+            self.pen_status = None
+            self.pen_events = deque()
+
+            self.hwnd = windll.user32.GetActiveWindow()
+
+            # inject our own wndProc to handle messages
+            # before window manager does
+            self.new_windProc = WNDPROC(self._pen_wndProc)
+            self.old_windProc = SetWindowLong_WndProc_wrapper(
+                self.hwnd, self.new_windProc)
+
+        def update(self, dispatch_fn):
+            while True:
+
+                try:
+                    etype, x, y = self.pen_events.pop()
+                except:
+                    break
+
+                if etype == 'begin':
+                    self.uid += 1
+                    self.pen = WM_Pen(self.device, self.uid, [x, y])
+                elif etype == 'update':
+                    self.pen.move([x, y])
+                elif etype == 'end':
+                    self.pen.update_time_end()
+
+                dispatch_fn(etype, self.pen)
+
+        def stop(self):
+            self.pen = None
+            SetWindowLong_WndProc_wrapper(self.hwnd, self.old_windProc)
+
+    MotionEventFactory.register('wm_pen', WM_PenProvider)
diff --git a/kivy/input/providers/wm_touch.py b/kivy/input/providers/wm_touch.py
new file mode 100644
index 0000000..8fdf098
--- /dev/null
+++ b/kivy/input/providers/wm_touch.py
@@ -0,0 +1,157 @@
+'''
+Support for WM_TOUCH messages (Windows platform)
+================================================
+'''
+
+__all__ = ('WM_MotionEventProvider', 'WM_MotionEvent')
+
+import os
+from kivy.input.providers.wm_common import WNDPROC, \
+    SetWindowLong_WndProc_wrapper, RECT, POINT, WM_TABLET_QUERYSYSTEMGESTURE, \
+    QUERYSYSTEMGESTURE_WNDPROC, WM_TOUCH, WM_MOUSEMOVE, WM_MOUSELAST, \
+    TOUCHINPUT, PEN_OR_TOUCH_MASK, PEN_OR_TOUCH_SIGNATURE, PEN_EVENT_TOUCH_MASK
+from kivy.input.motionevent import MotionEvent
+from kivy.input.shape import ShapeRect
+
+Window = None
+
+
+class WM_MotionEvent(MotionEvent):
+    '''MotionEvent representing the WM_MotionEvent event.
+       Supports pos, shape and size profiles.
+    '''
+    __attrs__ = ('size', )
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ('pos', 'shape', 'size')
+
+    def depack(self, args):
+        self.shape = ShapeRect()
+        self.sx, self.sy = args[0], args[1]
+        self.shape.width = args[2][0]
+        self.shape.height = args[2][1]
+        self.size = self.shape.width * self.shape.height
+        super().depack(args)
+
+    def __str__(self):
+        args = (self.id, self.uid, str(self.spos), self.device)
+        return '<WMMotionEvent id:%d uid:%d pos:%s device:%s>' % args
+
+
+if 'KIVY_DOC' in os.environ:
+    # documentation hack
+    WM_MotionEventProvider = None
+
+else:
+    from ctypes.wintypes import HANDLE
+    from ctypes import (windll, sizeof, byref)
+    from collections import deque
+    from kivy.input.provider import MotionEventProvider
+    from kivy.input.factory import MotionEventFactory
+
+    class WM_MotionEventProvider(MotionEventProvider):
+
+        def start(self):
+            global Window
+            if not Window:
+                from kivy.core.window import Window
+
+            self.touch_events = deque()
+            self.touches = {}
+            self.uid = 0
+
+            # get window handle, and register to receive WM_TOUCH messages
+            self.hwnd = windll.user32.GetActiveWindow()
+            windll.user32.RegisterTouchWindow(self.hwnd, 1)
+
+            # inject our own wndProc to handle messages
+            # before window manager does
+            self.new_windProc = WNDPROC(self._touch_wndProc)
+            self.old_windProc = SetWindowLong_WndProc_wrapper(
+                self.hwnd, self.new_windProc)
+
+        def update(self, dispatch_fn):
+            c_rect = RECT()
+            windll.user32.GetClientRect(self.hwnd, byref(c_rect))
+            pt = POINT(x=0, y=0)
+            windll.user32.ClientToScreen(self.hwnd, byref(pt))
+            x_offset, y_offset = pt.x, pt.y
+            usable_w, usable_h = float(c_rect.w), float(c_rect.h)
+
+            while True:
+                try:
+                    t = self.touch_events.pop()
+                except:
+                    break
+
+                # adjust x,y to window coordinates (0.0 to 1.0)
+                x = (t.screen_x() - x_offset) / usable_w
+                y = 1.0 - (t.screen_y() - y_offset) / usable_h
+
+                # actually dispatch input
+                if t.event_type == 'begin':
+                    self.uid += 1
+                    self.touches[t.id] = WM_MotionEvent(
+                        self.device, self.uid, [x, y, t.size()])
+                    dispatch_fn('begin', self.touches[t.id])
+
+                if t.event_type == 'update' and t.id in self.touches:
+                    self.touches[t.id].move([x, y, t.size()])
+                    dispatch_fn('update', self.touches[t.id])
+
+                if t.event_type == 'end' and t.id in self.touches:
+                    touch = self.touches[t.id]
+                    touch.move([x, y, t.size()])
+                    touch.update_time_end()
+                    dispatch_fn('end', touch)
+                    del self.touches[t.id]
+
+        def stop(self):
+            windll.user32.UnregisterTouchWindow(self.hwnd)
+            self.new_windProc = SetWindowLong_WndProc_wrapper(
+                self.hwnd, self.old_windProc)
+
+        # we inject this wndProc into our main window, to process
+        # WM_TOUCH and mouse messages before the window manager does
+        def _touch_wndProc(self, hwnd, msg, wParam, lParam):
+            done = False
+            if msg == WM_TABLET_QUERYSYSTEMGESTURE:
+                return QUERYSYSTEMGESTURE_WNDPROC
+
+            if msg == WM_TOUCH:
+                done = self._touch_handler(msg, wParam, lParam)
+
+            if msg >= WM_MOUSEMOVE and msg <= WM_MOUSELAST:
+                done = self._mouse_handler(msg, wParam, lParam)
+
+            if not done:
+                return windll.user32.CallWindowProcW(self.old_windProc,
+                                                     hwnd, msg, wParam,
+                                                     lParam)
+            return 1
+
+        # this on pushes WM_TOUCH messages onto our event stack
+        def _touch_handler(self, msg, wParam, lParam):
+            touches = (TOUCHINPUT * wParam)()
+            windll.user32.GetTouchInputInfo(HANDLE(lParam),
+                                            wParam,
+                                            touches,
+                                            sizeof(TOUCHINPUT))
+            for i in range(wParam):
+                self.touch_events.appendleft(touches[i])
+            windll.user32.CloseTouchInputHandle(HANDLE(lParam))
+            return True
+
+        # filter fake mouse events, because touch and stylus
+        # also make mouse events
+        def _mouse_handler(self, msg, wparam, lParam):
+            info = windll.user32.GetMessageExtraInfo()
+            # its a touch or a pen
+            if (info & PEN_OR_TOUCH_MASK) == PEN_OR_TOUCH_SIGNATURE:
+                if info & PEN_EVENT_TOUCH_MASK:
+                    return True
+
+    MotionEventFactory.register('wm_touch', WM_MotionEventProvider)
diff --git a/kivy/input/recorder.py b/kivy/input/recorder.py
new file mode 100644
index 0000000..7d1f077
--- /dev/null
+++ b/kivy/input/recorder.py
@@ -0,0 +1,335 @@
+'''
+Input recorder
+==============
+
+.. versionadded:: 1.1.0
+
+.. warning::
+
+    This part of Kivy is still experimental and this API is subject to
+    change in a future version.
+
+This is a class that can record and replay some input events. This can
+be used for test cases, screen savers etc.
+
+Once activated, the recorder will listen for any input event and save its
+properties in a file with the delta time. Later, you can play the input
+file: it will generate fake touch events with the saved properties and
+dispatch it to the event loop.
+
+By default, only the position is saved ('pos' profile and 'sx', 'sy',
+attributes). Change it only if you understand how input handling works.
+
+Recording events
+----------------
+
+The best way is to use the "recorder" module. Check the :doc:`api-kivy.modules`
+documentation to see how to activate a module.
+
+Once activated, you can press F8 to start the recording. By default,
+events will be written to `<currentpath>/recorder.kvi`. When you want to
+stop recording, press F8 again.
+
+You can replay the file by pressing F7.
+
+Check the :doc:`api-kivy.modules.recorder` module for more information.
+
+Manual play
+-----------
+
+You can manually open a recorder file, and play it by doing::
+
+    from kivy.input.recorder import Recorder
+
+    rec = Recorder(filename='myrecorder.kvi')
+    rec.play = True
+
+If you want to loop over that file, you can do::
+
+
+    from kivy.input.recorder import Recorder
+
+    def recorder_loop(instance, value):
+        if value is False:
+            instance.play = True
+
+    rec = Recorder(filename='myrecorder.kvi')
+    rec.bind(play=recorder_loop)
+    rec.play = True
+
+Recording more attributes
+-------------------------
+
+You can extend the attributes to save on one condition: attributes values must
+be simple values, not instances of complex classes.
+
+Let's say you want to save the angle and pressure of the touch, if available::
+
+    from kivy.input.recorder import Recorder
+
+    rec = Recorder(filename='myrecorder.kvi',
+        record_attrs=['is_touch', 'sx', 'sy', 'angle', 'pressure'],
+        record_profile_mask=['pos', 'angle', 'pressure'])
+    rec.record = True
+
+Or with modules variables::
+
+    $ python main.py -m recorder,attrs=is_touch:sx:sy:angle:pressure, \
+            profile_mask=pos:angle:pressure
+
+Known limitations
+-----------------
+
+  - Unable to save attributes with instances of complex classes.
+  - Values that represent time will not be adjusted.
+  - Can replay only complete records. If a begin/update/end event is missing,
+    this could lead to ghost touches.
+  - Stopping the replay before the end can lead to ghost touches.
+
+'''
+
+__all__ = ('Recorder', )
+
+from os.path import exists
+from time import time
+from kivy.event import EventDispatcher
+from kivy.properties import ObjectProperty, BooleanProperty, StringProperty, \
+    NumericProperty, ListProperty
+from kivy.input.motionevent import MotionEvent
+from kivy.base import EventLoop
+from kivy.logger import Logger
+from ast import literal_eval
+from functools import partial
+
+
+class RecorderMotionEvent(MotionEvent):
+
+    def depack(self, args):
+        for key, value in list(args.items()):
+            setattr(self, key, value)
+        super(RecorderMotionEvent, self).depack(args)
+
+
+class Recorder(EventDispatcher):
+    '''Recorder class. Please check module documentation for more information.
+
+    :Events:
+        `on_stop`:
+            Fired when the playing stops.
+
+    .. versionchanged:: 1.10.0
+        Event `on_stop` added.
+    '''
+
+    window = ObjectProperty(None)
+    '''Window instance to attach the recorder. If None, it will use the
+    default instance.
+
+    :attr:`window` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    counter = NumericProperty(0)
+    '''Number of events recorded in the last session.
+
+    :attr:`counter` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0, read-only.
+    '''
+
+    play = BooleanProperty(False)
+    '''Boolean to start/stop the replay of the current file (if it exists).
+
+    :attr:`play` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    record = BooleanProperty(False)
+    '''Boolean to start/stop the recording of input events.
+
+    :attr:`record` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    filename = StringProperty('recorder.kvi')
+    '''Filename to save the output of the recorder.
+
+    :attr:`filename` is a :class:`~kivy.properties.StringProperty` and defaults
+    to 'recorder.kvi'.
+    '''
+
+    record_attrs = ListProperty(['is_touch', 'sx', 'sy'])
+    '''Attributes to record from the motion event.
+
+    :attr:`record_attrs` is a :class:`~kivy.properties.ListProperty` and
+    defaults to ['is_touch', 'sx', 'sy'].
+    '''
+
+    record_profile_mask = ListProperty(['pos'])
+    '''Profile to save in the fake motion event when replayed.
+
+    :attr:`record_profile_mask` is a :class:`~kivy.properties.ListProperty` and
+    defaults to ['pos'].
+    '''
+
+    # internals
+    record_fd = ObjectProperty(None)
+    record_time = NumericProperty(0.)
+
+    __events__ = ('on_stop',)
+
+    def __init__(self, **kwargs):
+        super(Recorder, self).__init__(**kwargs)
+        if self.window is None:
+            # manually set the current window
+            from kivy.core.window import Window
+            self.window = Window
+        self.window.bind(
+            on_motion=self.on_motion,
+            on_key_up=partial(self.on_keyboard, 'keyup'),
+            on_key_down=partial(self.on_keyboard, 'keydown'),
+            on_keyboard=partial(self.on_keyboard, 'keyboard'))
+
+    def on_motion(self, window, etype, motionevent):
+        if not self.record:
+            return
+
+        args = dict((arg, getattr(motionevent, arg))
+                    for arg in self.record_attrs if hasattr(motionevent, arg))
+
+        args['profile'] = [x for x in motionevent.profile if x in
+                           self.record_profile_mask]
+        self.record_fd.write('%r\n' % (
+            (time() - self.record_time, etype, motionevent.uid, args), ))
+        self.counter += 1
+
+    def on_keyboard(self, etype, window, key, *args, **kwargs):
+        if not self.record:
+            return
+        self.record_fd.write('%r\n' % (
+            (time() - self.record_time, etype, 0, {
+                'key': key,
+                'scancode': kwargs.get('scancode'),
+                'codepoint': kwargs.get('codepoint', kwargs.get('unicode')),
+                'modifier': kwargs.get('modifier'),
+                'is_touch': False}), ))
+        self.counter += 1
+
+    def release(self):
+        self.window.unbind(
+            on_motion=self.on_motion,
+            on_key_up=self.on_keyboard,
+            on_key_down=self.on_keyboard)
+
+    def on_record(self, instance, value):
+        if value:
+            # generate a record filename
+            self.counter = 0
+            self.record_time = time()
+            self.record_fd = open(self.filename, 'w')
+            self.record_fd.write('#RECORDER1.0\n')
+            Logger.info('Recorder: Recording inputs to %r' % self.filename)
+        else:
+            self.record_fd.close()
+            Logger.info('Recorder: Recorded %d events in %r' % (self.counter,
+                                                                self.filename))
+
+    # needed for acting as an input provider
+    def stop(self):
+        pass
+
+    def start(self):
+        pass
+
+    def on_play(self, instance, value):
+        if not value:
+            Logger.info('Recorder: Stop playing %r' % self.filename)
+            EventLoop.remove_input_provider(self)
+            return
+        if not exists(self.filename):
+            Logger.error('Recorder: Unable to find %r file, play aborted.' % (
+                self.filename))
+            return
+
+        with open(self.filename, 'r') as fd:
+            data = fd.read().splitlines()
+
+        if len(data) < 2:
+            Logger.error('Recorder: Unable to play %r, file truncated.' % (
+                self.filename))
+            return
+
+        if data[0] != '#RECORDER1.0':
+            Logger.error('Recorder: Unable to play %r, invalid header.' % (
+                self.filename))
+            return
+
+        # decompile data
+        self.play_data = [literal_eval(x) for x in data[1:]]
+        self.play_time = time()
+        self.play_me = {}
+        Logger.info('Recorder: Start playing %d events from %r' %
+                    (len(self.play_data), self.filename))
+        EventLoop.add_input_provider(self)
+
+    def on_stop(self):
+        pass
+
+    def update(self, dispatch_fn):
+        if not self.play_data:
+            Logger.info('Recorder: Playing finished.')
+            self.play = False
+            self.dispatch('on_stop')
+
+        dt = time() - self.play_time
+        while self.play_data:
+            event = self.play_data[0]
+            assert(len(event) == 4)
+            if event[0] > dt:
+                return
+
+            me = None
+            etype, uid, args = event[1:]
+            if etype == 'begin':
+                me = RecorderMotionEvent('recorder', uid, args)
+                self.play_me[uid] = me
+            elif etype == 'update':
+                me = self.play_me[uid]
+                me.depack(args)
+            elif etype == 'end':
+                me = self.play_me.pop(uid)
+                me.depack(args)
+            elif etype == 'keydown':
+                self.window.dispatch(
+                    'on_key_down',
+                    args['key'],
+                    args['scancode'],
+                    args['codepoint'],
+                    args['modifier'])
+            elif etype == 'keyup':
+                self.window.dispatch(
+                    'on_key_up',
+                    args['key'],
+                    args['scancode'],
+                    args['codepoint'],
+                    args['modifier'])
+            elif etype == 'keyboard':
+                self.window.dispatch(
+                    'on_keyboard',
+                    args['key'],
+                    args['scancode'],
+                    args['codepoint'],
+                    args['modifier'])
+
+            if me:
+                dispatch_fn(etype, me)
+
+            self.play_data.pop(0)
+
+
+def start(win, ctx):
+    ctx.recorder = Recorder(window=win)
+
+
+def stop(win, ctx):
+    if hasattr(ctx, 'recorder'):
+        ctx.recorder.release()
diff --git a/kivy/input/shape.py b/kivy/input/shape.py
new file mode 100644
index 0000000..320c057
--- /dev/null
+++ b/kivy/input/shape.py
@@ -0,0 +1,27 @@
+'''
+Motion Event Shape
+==================
+
+Represent the shape of the :class:`~kivy.input.motionevent.MotionEvent`
+'''
+
+__all__ = ('Shape', 'ShapeRect')
+
+
+class Shape(object):
+    '''Abstract class for all implementations of a shape'''
+    pass
+
+
+class ShapeRect(Shape):
+    '''Class for the representation of a rectangle.'''
+    __slots__ = ('width', 'height')
+
+    def __init__(self):
+        super(ShapeRect, self).__init__()
+
+        #: Width of the rect
+        self.width = 0
+
+        #: Height of the rect
+        self.height = 0
diff --git a/kivy/interactive.py b/kivy/interactive.py
new file mode 100644
index 0000000..5004593
--- /dev/null
+++ b/kivy/interactive.py
@@ -0,0 +1,335 @@
+'''
+Interactive launcher
+====================
+
+.. versionadded:: 1.3.0
+
+.. deprecated:: 1.10.0
+    The interactive launcher has been deprecated.
+
+The :class:`InteractiveLauncher` provides a user-friendly python shell
+interface to an :class:`App` so that it can be prototyped and debugged
+interactively.
+
+.. note::
+
+    The Kivy API intends for some functions to only be run once or before the
+    main EventLoop has started. Methods that can normally be called during the
+    course of an application will work as intended, but specifically overriding
+    methods such as :meth:`on_touch` dynamically leads to trouble.
+
+Creating an InteractiveLauncher
+-------------------------------
+
+Take your existing subclass of :class:`App` (this can be production code) and
+pass an instance to the :class:`InteractiveLauncher` constructor. ::
+
+    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()
+
+After pressing *enter*, the script will return. This allows the interpreter to
+continue running. Inspection or modification of the :class:`App` can be done
+safely through the InteractiveLauncher instance or the provided
+:class:`SafeMembrane` class instances.
+
+.. note::
+
+    If you want to test this example, start Python without any file to have
+    already an interpreter, and copy/paste all the lines. You'll still have the
+    interpreter at the end + the kivy application running.
+
+Interactive Development
+-----------------------
+
+IPython provides a fast way to learn the Kivy API. The :class:`App` instance
+and all of its attributes, including methods and the entire widget tree,
+can be quickly listed by using the '.' operator and pressing 'tab'. Try this
+code in an Ipython shell. ::
+
+    from kivy.interactive import InteractiveLauncher
+    from kivy.app import App
+    from kivy.uix.widget import Widget
+    from kivy.graphics import Color, Ellipse
+
+    class MyPaintWidget(Widget):
+        def on_touch_down(self, touch):
+            with self.canvas:
+                Color(1, 1, 0)
+                d = 30.
+                Ellipse(pos=(touch.x - d/2, touch.y - d/2), size=(d, d))
+
+
+    class TestApp(App):
+        def build(self):
+            return Widget()
+
+
+    i = InteractiveLauncher(TestApp())
+    i.run()
+    i.       # press 'tab' to list attributes of the app
+    i.root.  # press 'tab' to list attributes of the root widget
+
+    # App is boring. Attach a new widget!
+    i.root.add_widget(MyPaintWidget())
+
+    i.safeIn()
+    # The application is now blocked.
+    # Click on the screen several times.
+    i.safeOut()
+    # The clicks will show up now
+
+    # Erase artwork and start over
+    i.root.canvas.clear()
+
+.. note::
+
+    All of the proxies used in the module store their referent in the
+    :attr:`_ref` attribute, which can be accessed directly if needed, such as
+    for getting doc strings. :func:`help` and :func:`type` will access the
+    proxy, not its referent.
+
+Directly Pausing the Application
+--------------------------------
+
+Both the :class:`InteractiveLauncher` and :class:`SafeMembrane` hold internal
+references to the :class:`EventLoop`'s 'safe' and 'confirmed'
+:class:`threading.Event` objects. You can use their safing methods to control
+the application manually.
+
+:meth:`SafeMembrane.safeIn` will cause the application to pause and
+:meth:`SafeMembrane.safeOut` will allow a paused application
+to continue running. This is potentially useful for scripting actions into
+functions that need the screen to update etc.
+
+.. note::
+
+    The pausing is implemented via the
+    :class:`Clocks' <kivy.clock.Clock>`
+    :meth:`~kivy.clock.ClockBase.schedule_once` method
+    and occurs before the start of each frame.
+
+Adding Attributes Dynamically
+-----------------------------
+
+.. note::
+
+    This module uses threading and object proxies to encapsulate the running
+    :class:`App`. Deadlocks and memory corruption can occur if making direct
+    references inside the thread without going through the provided proxy(s).
+
+The :class:`InteractiveLauncher` can have attributes added to it exactly like a
+normal object and if these were created from outside the membrane, they will
+not be threadsafe because the external references to them in the python
+interpreter do not go through InteractiveLauncher's membrane behavior,
+inherited from :class:`SafeMembrane`.
+
+To threadsafe these external references, simply assign them to
+:class:`SafeMembrane` instances of themselves like so::
+
+    from kivy.interactive import SafeMembrane
+
+    interactiveLauncher.attribute = myNewObject
+    # myNewObject is unsafe
+    myNewObject = SafeMembrane(myNewObject)
+    # myNewObject is now safe. Call at will.
+    myNewObject.method()
+
+TODO
+====
+
+Unit tests, examples, and a better explanation of which methods are safe in a
+running application would be nice. All three would be excellent.
+
+Could be re-written with a context-manager style i.e. ::
+
+    with safe:
+        foo()
+
+Any use cases besides compacting code?
+
+'''
+
+__all__ = ('SafeMembrane', 'InteractiveLauncher')
+
+import inspect
+from threading import Thread, Event
+
+from kivy.app import App
+from kivy.base import EventLoop
+from kivy.clock import Clock
+from kivy.utils import deprecated
+
+
+def safeWait(dt):
+    EventLoop.confirmed.set()
+    EventLoop.safe.wait()
+    EventLoop.confirmed.clear()
+
+
+def unwrap(ob):
+    while type(ob) == SafeMembrane:
+        ob = ob._ref
+    return ob
+
+
+class SafeMembrane(object):
+    '''
+    This help is for a proxy object. Did you want help on the proxy's referent
+    instead? Try using help(<instance>._ref)
+
+    The SafeMembrane is a threadsafe proxy that also returns attributes as new
+    thread-safe objects
+    and makes thread-safe method calls, preventing thread-unsafe objects
+    from leaking into the user's environment.
+    '''
+
+    __slots__ = ('_ref', 'safe', 'confirmed')
+
+    def __init__(self, ob, *args, **kwargs):
+        self.confirmed = EventLoop.confirmed
+        self.safe = EventLoop.safe
+        self._ref = ob
+
+    def safeIn(self):
+        """Provides a thread-safe entry point for interactive launching."""
+        self.safe.clear()
+        Clock.schedule_once(safeWait, -1)
+        self.confirmed.wait()
+
+    def safeOut(self):
+        """Provides a thread-safe exit point for interactive launching."""
+        self.safe.set()
+
+    def isMethod(self, fn):
+        return inspect.ismethod(fn)
+
+    # Everything from this point on is just a series of thread-safing proxy
+    # methods that make calls against _ref and threadsafe whenever data will be
+    # written to or if a method will be called. SafeMembrane instances should
+    # be unwrapped whenever passing them into the thread
+    # use type() to determine if an object is a SafeMembrane while debugging
+    def __repr__(self):
+        return self._ref.__repr__()
+
+    def __call__(self, *args, **kw):
+        self.safeIn()
+        args = list(map(unwrap, args))
+        for k in list(kw.keys()):
+            kw[k] = unwrap(kw[k])
+        r = self._ref(*args, **kw)
+        self.safeOut()
+        if r is not None:
+            return SafeMembrane(r)
+
+    def __getattribute__(self, attr, oga=object.__getattribute__):
+        if attr.startswith('__') or attr == '_ref':
+            subject = oga(self, '_ref')
+            if attr == '_ref':
+                return subject
+            return getattr(subject, attr)
+        return oga(self, attr)
+
+    def __getattr__(self, attr, oga=object.__getattribute__):
+        r = getattr(oga(self, '_ref'), attr)
+        return SafeMembrane(r)
+
+    def __setattr__(self, attr, val, osa=object.__setattr__):
+        if (attr == '_ref' or
+                hasattr(type(self), attr) and not attr.startswith('__')):
+            osa(self, attr, val)
+        else:
+            self.safeIn()
+            val = unwrap(val)
+            setattr(self._ref, attr, val)
+            self.safeOut()
+
+    def __delattr__(self, attr, oda=object.__delattr__):
+        self.safeIn()
+        delattr(self._ref, attr)
+        self.safeOut()
+
+    def __bool__(self):
+        return bool(self._ref)
+
+    def __getitem__(self, arg):
+        return SafeMembrane(self._ref[arg])
+
+    def __setitem__(self, arg, val):
+        self.safeIn()
+        val = unwrap(val)
+        self._ref[arg] = val
+        self.safeOut()
+
+    def __delitem__(self, arg):
+        self.safeIn()
+        del self._ref[arg]
+        self.safeOut()
+
+    def __getslice__(self, i, j):
+        return SafeMembrane(self._ref[i:j])
+
+    def __setslice__(self, i, j, val):
+        self.safeIn()
+        val = unwrap(val)
+        self._ref[i:j] = val
+        self.safeOut()
+
+    def __delslice__(self, i, j):
+        self.safeIn()
+        del self._ref[i:j]
+        self.safeOut()
+
+    def __enter__(self, *args, **kwargs):
+        self.safeIn()
+        self._ref.__enter__(*args, **kwargs)
+
+    def __exit__(self, *args, **kwargs):
+        self._ref.__exit__(*args, **kwargs)
+        self.safeOut()
+
+
+class InteractiveLauncher(SafeMembrane):
+    '''
+    Proxy to an application instance that launches it in a thread and
+    then returns and acts as a proxy to the application in the thread.
+    '''
+
+    __slots__ = ('_ref', 'safe', 'confirmed', 'thread', 'app')
+
+    @deprecated
+    def __init__(self, app=None, *args, **kwargs):
+        if app is None:
+            app = App()
+        EventLoop.safe = Event()
+        self.safe = EventLoop.safe
+        self.safe.set()
+        EventLoop.confirmed = Event()
+        self.confirmed = EventLoop.confirmed
+        self.app = app
+
+        def startApp(app=app, *args, **kwargs):
+            app.run(*args, **kwargs)
+
+        self.thread = Thread(target=startApp, *args, **kwargs)
+
+    def run(self):
+        self.thread.start()
+        # Proxy behavior starts after this is set. Before this point, attaching
+        # widgets etc can only be done through the Launcher's app attribute
+        self._ref = self.app
+
+    def stop(self):
+        EventLoop.quit = True
+        self.thread.join()
+
+    # Act like the app instance even before _ref is set
+    def __repr__(self):
+        return self.app.__repr__()
diff --git a/kivy/lang/__init__.py b/kivy/lang/__init__.py
new file mode 100644
index 0000000..348ea87
--- /dev/null
+++ b/kivy/lang/__init__.py
@@ -0,0 +1,883 @@
+'''Kivy Language
+=============
+
+The Kivy language is a language dedicated to describing user interface and
+interactions. You could compare this language to Qt's QML
+(http://qt.nokia.com), but we included new concepts such as rule definitions
+(which are somewhat akin to what you may know from CSS), templating and so on.
+
+.. versionchanged:: 1.7.0
+
+    The Builder doesn't execute canvas expressions in realtime anymore. It will
+    pack all the expressions that need to be executed first and execute them
+    after dispatching input, just before drawing the frame. If you want to
+    force the execution of canvas drawing, just call
+    :meth:`Builder.sync <BuilderBase.sync>`.
+
+    An experimental profiling tool for the kv lang is also included. You can
+    activate it by setting the environment variable `KIVY_PROFILE_LANG=1`.
+    It will then generate an html file named `builder_stats.html`.
+
+Overview
+--------
+
+The language consists of several constructs that you can use:
+
+    Rules
+        A rule is similar to a CSS rule. A rule applies to specific widgets (or
+        classes thereof) in your widget tree and modifies them in a
+        certain way.
+        You can use rules to specify interactive behaviour or use them to add
+        graphical representations of the widgets they apply to.
+        You can target a specific class of widgets (similar to the CSS
+        concept of a *class*) by using the ``cls`` attribute (e.g.
+        ``cls=MyTestWidget``).
+
+    A Root Widget
+        You can use the language to create your entire user interface.
+        A kv file must contain only one root widget at most.
+
+    Dynamic Classes
+        *(introduced in version 1.7.0)*
+        Dynamic classes let you create new widgets and rules on-the-fly,
+        without any Python declaration.
+
+    Templates (deprecated)
+        *(introduced in version 1.0.5, deprecated from version 1.7.0)*
+        Templates were used to populate parts of an application, such as
+        styling the content of a list (e.g. icon on the left, text on the
+        right). They are now deprecated by dynamic classes.
+
+
+Syntax of a kv File
+-------------------
+
+.. highlight:: kv
+
+A Kivy language file must have ``.kv`` as filename extension.
+
+The content of the file should always start with the Kivy header, where
+`version` must be replaced with the Kivy language version you're using.
+For now, use 1.0::
+
+    #:kivy `1.0`
+
+    # content here
+
+The `content` can contain rule definitions, a root widget, dynamic class
+definitions and templates::
+
+    # 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 ..
+
+Regardless of whether it's a rule, root widget, dynamic class or
+template you're defining, the definition should look like this::
+
+    # 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
+
+Here `prop1` and `prop2` are the properties of `ClassName` and `prop3` is the
+property of `AnotherClass`. If the widget doesn't have a property with
+the given name, an :class:`~kivy.properties.ObjectProperty` will be
+automatically created and added to the widget.
+
+`AnotherClass` will be created and added as a child of the `ClassName`
+instance.
+
+- The indentation is important and must be consistent. The spacing must be a
+  multiple of the number of spaces used on the first indented line. Spaces
+  are encouraged: mixing tabs and spaces is not recommended.
+- The value of a property must be given on a single line (for now at least).
+- Keep class names capitalized to avoid syntax errors.
+- The `canvas` property is special: you can put graphics instructions in it
+  to create a graphical representation of the current class.
+
+
+Here is a simple example of a kv file that contains a root widget::
+
+    #:kivy 1.0
+
+    Button:
+        text: 'Hello world'
+
+
+.. versionchanged:: 1.7.0
+
+    The indentation is not limited to 4 spaces anymore. The spacing must be a
+    multiple of the number of spaces used on the first indented line.
+
+Both the :meth:`~BuilderBase.load_file` and the
+:meth:`~BuilderBase.load_string` methods
+return the root widget defined in your kv file/string. They will also add any
+class and template definitions to the :class:`~kivy.factory.Factory` for later
+usage.
+
+Value Expressions, on_property Expressions, ids, and Reserved Keywords
+---------------------------------------------------------------------
+
+When you specify a property's value, the value is evaluated as a Python
+expression. This expression can be static or dynamic, which means that
+the value can use the values of other properties using reserved keywords.
+
+    self
+        The keyword self references the "current widget instance"::
+
+            Button:
+                text: 'My state is %s' % self.state
+
+    root
+        This keyword is available only in rule definitions and represents the
+        root widget of the rule (the first instance of the rule)::
+
+            <MyWidget>:
+                custom: 'Hello world'
+                Button:
+                    text: root.custom
+
+    app
+        This keyword always refers to your app instance. It's equivalent
+        to a call to :meth:`kivy.app.App.get_running_app` in Python. ::
+
+            Label:
+                text: app.name
+
+    args
+        This keyword is available in on_<action> callbacks. It refers to the
+        arguments passed to the callback. ::
+
+            TextInput:
+                on_focus: self.insert_text("Focus" if args[1] else "No focus")
+
+
+.. versionchanged:: 2.1.0
+
+    f-strings are now parsed in value expressions, allowing to bind to the
+    properties that they contain.
+
+.. kv-lang-ids:
+
+ids
+~~~
+
+Class definitions may contain ids which can be used as a keywords:::
+
+    <MyWidget>:
+        Button:
+            id: btn1
+        Button:
+            text: 'The state of the other button is %s' % btn1.state
+
+Please note that the `id` will not be available in the widget instance:
+it is used exclusively for external references. `id` is a weakref to the
+widget, and not the widget itself. The widget itself can be accessed
+with `<id>.__self__` (`btn1.__self__` in this case).
+
+When the kv file is processed, weakrefs to all the widgets tagged with ids are
+added to the root widget's `ids` dictionary. In other words, following on from
+the example above, the buttons state could also be accessed as follows:
+
+.. code-block:: python
+
+    widget = MyWidget()
+    state = widget.ids["btn1"].state
+
+    # Or, as an alternative syntax,
+    state = widget.ids.btn1.state
+
+Note that the outermost widget applies the kv rules to all its inner widgets
+before any other rules are applied. This means if an inner widget contains ids,
+these ids may not be available during the inner widget's `__init__` function.
+
+Valid expressions
+~~~~~~~~~~~~~~~~~
+
+There are two places that accept python statements in a kv file:
+after a property, which assigns to the property the result of the expression
+(such as the text of a button as shown above) and after a on_property, which
+executes the statement when the property is updated (such as on_state).
+
+In the former case, the
+`expression <http://docs.python.org/2/reference/expressions.html>`_ can only
+span a single line, cannot be extended to multiple lines using newline
+escaping, and must return a value. An example of a valid expression is
+``text: self.state and ('up' if self.state == 'normal' else 'down')``.
+
+In the latter case, multiple single line statements are valid, including
+those that escape their newline, as long as they don't add an indentation
+level.
+
+Examples of valid statements are:
+
+.. code-block:: python
+
+    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])
+
+An example of a invalid statement:
+
+.. code-block:: python
+
+    on_state:
+        if self.state == 'normal':
+            print('normal')
+
+Relation Between Values and Properties
+--------------------------------------
+
+When you use the Kivy language, you might notice that we do some work
+behind the scenes to automatically make things work properly. You should
+know that :doc:`api-kivy.properties` implement the
+`Observer Design Pattern <http://en.wikipedia.org/wiki/Observer_pattern>`_.
+That means that you can bind your own function to be
+called when the value of a property changes (i.e. you passively
+`observe` the property for potential changes).
+
+The Kivy language detects properties in your `value` expression and will create
+callbacks to automatically update the property via your expression when changes
+occur.
+
+Here's a simple example that demonstrates this behaviour::
+
+    Button:
+        text: str(self.state)
+
+In this example, the parser detects that `self.state` is a dynamic value (a
+property). The :attr:`~kivy.uix.button.Button.state` property of the button
+can change at any moment (when the user touches it).
+We now want this button to display its own state as text, even as the state
+changes. To do this, we use the state property of the Button and use it in the
+value expression for the button's `text` property, which controls what text is
+displayed on the button (We also convert the state to a string representation).
+Now, whenever the button state changes, the text property will be updated
+automatically.
+
+Remember: The value is a python expression! That means that you can do
+something more interesting like::
+
+    Button:
+        text: 'Plop world' if self.state == 'normal' else 'Release me!'
+
+The Button text changes with the state of the button. By default, the button
+text will be 'Plop world', but when the button is being pressed, the text will
+change to 'Release me!'.
+
+More precisely, the kivy language parser detects all substrings of the form
+`X.a.b` where `X` is `self` or `root` or `app` or a known id, and `a` and `b`
+are properties: it then adds the appropriate dependencies to cause the
+the constraint to be reevaluated whenever something changes. For example,
+this works exactly as expected::
+
+    <IndexedExample>:
+        beta: self.a.b[self.c.d]
+
+However, due to limitations in the parser which hopefully may be lifted in the
+future, the following doesn't work::
+
+    <BadExample>:
+        beta: self.a.b[self.c.d].e.f
+
+indeed the `.e.f` part is not recognized because it doesn't follow the expected
+pattern, and so, does not result in an appropriate dependency being setup.
+Instead, an intermediate property should be introduced to allow the following
+constraint::
+
+    <GoodExample>:
+        alpha: self.a.b[self.c.d]
+        beta: self.alpha.e.f
+
+In addition, properties in python f-strings are also not yet supported::
+
+    <FStringExample>:
+        text: f"I want to use {self.a} in property"
+
+Instead, the ``format()`` method should be used::
+
+    <FormatStringExample>:
+        text: "I want to use {} in property".format(self.a)
+
+
+Graphical Instructions
+----------------------
+
+The graphical instructions are a special part of the Kivy language. They are
+handled by the 'canvas' property definition::
+
+    Widget:
+        canvas:
+            Color:
+                rgb: (1, 1, 1)
+            Rectangle:
+                size: self.size
+                pos: self.pos
+
+All the classes added inside the canvas property must be derived from the
+:class:`~kivy.graphics.Instruction` class. You cannot put any Widget class
+inside the canvas property (as that would not make sense because a
+widget is not a graphics instruction).
+
+If you want to do theming, you'll have the same question as in CSS: which rules
+have been executed first? In our case, the rules are executed
+in processing order (i.e. top-down).
+
+If you want to change how Buttons are rendered, you can create your own kv file
+and add something like this::
+
+    <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
+
+This will result in buttons having a red background with the label in the
+bottom left, in addition to all the preceding rules.
+You can clear all the previous instructions by using the `Clear` command::
+
+    <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
+
+Then, only your rules that follow the `Clear` command will be taken into
+consideration.
+
+.. _dynamic_classes:
+
+Dynamic classes
+---------------
+
+Dynamic classes allow you to create new widgets on-the-fly, without any python
+declaration in the first place. The syntax of the dynamic classes is similar to
+the Rules, but you need to specify the base classes you want to
+subclass.
+
+The syntax looks like:
+
+.. code-block:: kv
+
+    # Simple inheritance
+    <NewWidget@Button>:
+        # kv code here ...
+
+    # Multiple inheritance
+    <NewWidget@ButtonBehavior+Label>:
+        # kv code here ...
+
+The `@` character is used to separate your class name from the classes you want
+to subclass. The Python equivalent would have been:
+
+.. code-block:: python
+
+    # Simple inheritance
+    class NewWidget(Button):
+        pass
+
+    # Multiple inheritance
+    class NewWidget(ButtonBehavior, Label):
+        pass
+
+Any new properties, usually added in python code, should be declared
+first. If the property doesn't exist in the dynamic class, it will be
+automatically created as an :class:`~kivy.properties.ObjectProperty`
+(pre 1.8.0) or as an appropriate typed property (from version
+1.8.0).
+
+.. versionchanged:: 1.8.0
+
+    If the property value is an expression that can be evaluated right away (no
+    external binding), then the value will be used as default value of the
+    property, and the type of the value will be used for the specialization of
+    the Property class. In other terms: if you declare `hello: "world"`, a new
+    :class:`~kivy.properties.StringProperty` will be instantiated, with the
+    default value `"world"`. Lists, tuples, dictionaries and strings are
+    supported.
+
+Let's illustrate the usage of these dynamic classes with an
+implementation of a basic Image button. We could derive our classes from
+the Button and just add a property for the image filename:
+
+.. code-block:: kv
+
+    <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()
+
+In Python, you can create an instance of the dynamic class as follows:
+
+.. code-block:: python
+
+    from kivy.factory import Factory
+    button_inst = Factory.ImageButton()
+
+.. note::
+
+    Using dynamic classes, a child class can be declared before its parent.
+    This however, leads to the unintuitive situation where the parent
+    properties/methods override those of the child. Be careful if you choose
+    to do this.
+
+.. _template_usage:
+
+Templates
+---------
+
+.. versionchanged:: 1.7.0
+
+    Template usage is now deprecated. Please use Dynamic classes instead.
+
+Syntax of templates
+~~~~~~~~~~~~~~~~~~~
+
+Using a template in Kivy requires 2 things :
+
+    #. a context to pass for the context (will be ctx inside template).
+    #. a kv definition of the template.
+
+Syntax of a template:
+
+.. code-block:: kv
+
+    # With only one base class
+    [ClassName@BaseClass]:
+        # .. definitions ..
+
+    # With more than one base class
+    [ClassName@BaseClass1,BaseClass2]:
+        # .. definitions ..
+
+For example, for a list, you'll need to create a entry with a image on
+the left, and a label on the right. You can create a template for making
+that definition easier to use.
+So, we'll create a template that uses 2 entries in the context: an image
+filename and a title:
+
+.. code-block:: kv
+
+    [IconItem@BoxLayout]:
+        Image:
+            source: ctx.image
+        Label:
+            text: ctx.title
+
+Then in Python, you can instantiate the template using:
+
+.. code-block:: python
+
+    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.
+
+
+Template example
+~~~~~~~~~~~~~~~~
+
+Most of time, when you are creating a screen in the kv lang, you use a lot of
+redefinitions. In our example, we'll create a Toolbar, based on a
+BoxLayout, and put in a few :class:`~kivy.uix.image.Image` widgets that
+will react to the *on_touch_down* event.
+
+.. code-block:: kv
+
+    <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()
+
+We can see that the size and size_hint attribute are exactly the same.
+More than that, the callback in on_touch_down and the image are changing.
+These can be the variable part of the template that we can put into a context.
+Let's try to create a template for the Image:
+
+.. code-block:: kv
+
+    [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()
+
+The template can be used directly in the MyToolbar rule:
+
+.. code-block:: kv
+
+    <MyToolbar>:
+        BoxLayout:
+            ToolbarButton:
+                image: 'text'
+                callback: root.create_text
+            ToolbarButton:
+                image: 'image'
+                callback: root.create_image
+            ToolbarButton:
+                image: 'video'
+                callback: root.create_video
+
+That's all :)
+
+
+Template limitations
+~~~~~~~~~~~~~~~~~~~~
+
+When you are creating a context:
+
+    #. you cannot use references other than "root":
+
+        .. code-block:: kv
+
+            <MyRule>:
+                Widget:
+                    id: mywidget
+                    value: 'bleh'
+                Template:
+                    ctxkey: mywidget.value # << fail, this references the id
+                    # mywidget
+
+    #. not all of the dynamic parts will be understood:
+
+        .. code-block:: kv
+
+            <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
+
+Template definitions also replace any similarly named definitions in their
+entirety and thus do not support inheritance.
+
+.. _redefining-style:
+
+Redefining a widget's style
+---------------------------
+
+Sometimes we would like to inherit from a widget in order to use its Python
+properties without also using its .kv defined style. For example, we would
+like to inherit from a Label, but we would also like to define our own
+canvas instructions instead of automatically using the canvas instructions
+inherited from the Label. We can achieve this by prepending a dash (-) before
+the class name in the .kv style definition.
+
+In myapp.py:
+
+.. code-block:: python
+
+    class MyWidget(Label):
+        pass
+
+and in my.kv:
+
+.. code-block:: kv
+
+    <-MyWidget>:
+        canvas:
+            Color:
+                rgb: 1, 1, 1
+            Rectangle:
+                size: (32, 32)
+
+MyWidget will now have a Color and Rectangle instruction in its canvas
+without any of the instructions inherited from the Label.
+
+Redefining a widget's property style
+------------------------------------
+
+Similar to :ref:`redefining style <redefining-style>`, sometimes we
+would like to inherit from a widget, keep all its KV defined styles, except for
+the style applied to a specific property. For example, we would
+like to inherit from a :class:`~kivy.uix.button.Button`, but we would also
+like to set our own `state_image`, rather then relying on the
+`background_normal` and `background_down` values. We can achieve this by
+prepending a dash (-) before the `state_image` property name in the .kv style
+definition.
+
+In myapp.py:
+
+.. code-block:: python
+
+    class MyWidget(Button):
+        new_background = StringProperty('my_background.png')
+
+and in my.kv:
+
+.. code-block:: kv
+
+    <MyWidget>:
+        -state_image: self.new_background
+
+MyWidget will now have a `state_image` background set only by `new_background`,
+and not by any previous styles that may have set `state_image`.
+
+.. note::
+
+    Although the previous rules are cleared, they are still applied during
+    widget construction and are only removed when the new rule with the dash
+    is reached. This means that initially, previous rules could be used to set
+    the property.
+
+Order of kwargs and KV rule application
+---------------------------------------
+
+Properties can be initialized in KV as well as in python. For example, in KV:
+
+.. code-block:: kv
+
+    <MyRule@Widget>:
+        text: 'Hello'
+        ramp: 45.
+        order: self.x + 10
+
+Then `MyRule()` would initialize all three kivy properties to
+the given KV values. Separately in python, if the properties already exist as
+kivy properties one can do for example `MyRule(line='Bye', side=55)`.
+
+However, what will be the final values of the properties when
+`MyRule(text='Bye', order=55)` is executed? The quick rule is that python
+initialization is stronger than KV initialization only for constant rules.
+
+Specifically, the `kwargs` provided to the python initializer are always
+applied first. So in the above example, `text` is set to
+`'Bye'` and `order` is set to `55`. Then, all the KV rules are applied, except
+those constant rules that overwrite a python initializer provided value.
+
+That is, the KV rules that do not creates bindings such as `text: 'Hello'`
+and `ramp: 45.`, if a value for that property has been provided in python, then
+that rule will not be applied.
+
+So in the `MyRule(text='Bye', order=55)` example, `text` will be `'Bye'`,
+`ramp` will be `45.`, and `order`, which creates a binding, will first be set
+to `55`, but then when KV rules are applied will end up being whatever
+`self.x + 10` is.
+
+.. versionchanged:: 1.9.1
+
+    Before, KV rules always overwrote the python values, now, python values
+    are not overwritten by constant rules.
+
+
+Lang Directives
+---------------
+
+You can use directives to add declarative commands, such as imports or constant
+definitions, to the lang files. Directives are added as comments in the
+following format:
+
+.. code-block:: kv
+
+    #:<directivename> <options>
+
+import <package>
+~~~~~~~~~~~~~~~~
+
+.. versionadded:: 1.0.5
+
+Syntax:
+
+.. code-block:: kv
+
+    #:import <alias> <package>
+
+You can import a package by writing:
+
+.. code-block:: kv
+
+    #:import os os
+
+    <Rule>:
+        Button:
+            text: os.getcwd()
+
+Or more complex:
+
+.. code-block:: kv
+
+    #:import ut kivy.utils
+
+    <Rule>:
+        canvas:
+            Color:
+                rgba: ut.get_random_color()
+
+.. versionadded:: 1.0.7
+
+You can directly import classes from a module:
+
+.. code-block:: kv
+
+    #: import Animation kivy.animation.Animation
+    <Rule>:
+        on_prop: Animation(x=.5).start(self)
+
+set <key> <expr>
+~~~~~~~~~~~~~~~~
+
+.. versionadded:: 1.0.6
+
+Syntax:
+
+.. code-block:: kv
+
+    #:set <key> <expr>
+
+Set a key that will be available anywhere in the kv. For example:
+
+.. code-block:: kv
+
+    #: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 <file>
+~~~~~~~~~~~~~~~~
+
+.. versionadded:: 1.9.0
+
+Syntax:
+
+.. code-block:: kv
+
+    #:include [force] <file>
+
+Includes an external kivy file. This allows you to split complex
+widgets into their own files. If the include is forced, the file
+will first be unloaded and then reloaded again. For example:
+
+.. code-block:: kv
+
+    # Test.kv
+    #:include mycomponent.kv
+    #:include force mybutton.kv
+
+    <Rule>:
+        state: 'normal'
+        MyButton:
+        MyComponent:
+
+
+.. code-block:: kv
+
+    # mycomponent.kv
+    #:include mybutton.kv
+
+    <MyComponent>:
+        MyButton:
+
+.. code-block:: kv
+
+    # 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)
+
+'''
+
+
+from kivy.lang.builder import (Observable, Builder, BuilderBase,
+                               BuilderException)
+from kivy.lang.parser import Parser, ParserException, global_idmap
+
+__all__ = ('Observable', 'Builder', 'BuilderBase', 'BuilderException',
+           'Parser', 'ParserException', 'global_idmap')
diff --git a/kivy/lang/__pycache__/__init__.cpython-310.pyc b/kivy/lang/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..5d9685a
Binary files /dev/null and b/kivy/lang/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/lang/__pycache__/builder.cpython-310.pyc b/kivy/lang/__pycache__/builder.cpython-310.pyc
new file mode 100644
index 0000000..6e45f59
Binary files /dev/null and b/kivy/lang/__pycache__/builder.cpython-310.pyc differ
diff --git a/kivy/lang/__pycache__/parser.cpython-310.pyc b/kivy/lang/__pycache__/parser.cpython-310.pyc
new file mode 100644
index 0000000..c641671
Binary files /dev/null and b/kivy/lang/__pycache__/parser.cpython-310.pyc differ
diff --git a/kivy/lang/builder.py b/kivy/lang/builder.py
new file mode 100644
index 0000000..092362e
--- /dev/null
+++ b/kivy/lang/builder.py
@@ -0,0 +1,999 @@
+'''
+Builder
+======
+
+Class used for the registering and application of rules for specific widgets.
+'''
+import sys
+from os import environ
+from os.path import join
+from copy import copy
+from types import CodeType
+from functools import partial
+
+from kivy.factory import Factory
+from kivy.lang.parser import Parser, ParserException, _handlers, global_idmap,\
+    ParserRuleProperty
+from kivy.logger import Logger
+from kivy.utils import QueryDict
+from kivy.cache import Cache
+from kivy import kivy_data_dir
+from kivy.context import register_context
+from kivy.resources import resource_find
+from kivy._event import Observable, EventDispatcher
+
+__all__ = ('Observable', 'Builder', 'BuilderBase', 'BuilderException')
+
+
+trace = Logger.trace
+
+# late import
+Instruction = None
+
+# delayed calls are canvas expression triggered during an loop. It is one
+# directional linked list of args to call call_fn with. Each element is a list
+# whose last element points to the next list of args to execute when
+# Builder.sync is called.
+_delayed_start = None
+
+
+class BuilderException(ParserException):
+    '''Exception raised when the Builder failed to apply a rule on a widget.
+    '''
+    pass
+
+
+def get_proxy(widget):
+    try:
+        return widget.proxy_ref
+    except AttributeError:
+        return widget
+
+
+def custom_callback(__kvlang__, idmap, *largs, **kwargs):
+    idmap['args'] = largs
+    exec(__kvlang__.co_value, idmap)
+
+
+def call_fn(args, instance, v):
+    element, key, value, rule, idmap = args
+    if __debug__:
+        trace('Lang: call_fn %s, key=%s, value=%r, %r' % (
+            element, key, value, rule.value))
+    rule.count += 1
+    e_value = eval(value, idmap)
+    if __debug__:
+        trace('Lang: call_fn => value=%r' % (e_value, ))
+    setattr(element, key, e_value)
+
+
+def delayed_call_fn(args, instance, v):
+    # it's already on the list
+    if args[-1] is not None:
+        return
+
+    global _delayed_start
+    if _delayed_start is None:
+        _delayed_start = args
+        args[-1] = StopIteration
+    else:
+        args[-1] = _delayed_start
+        _delayed_start = args
+
+
+def update_intermediates(base, keys, bound, s, fn, args, instance, value):
+    ''' Function that is called when an intermediate property is updated
+    and `rebind` of that property is True. In that case, we unbind
+    all bound funcs that were bound to attrs of the old value of the
+    property and rebind to the new value of the property.
+
+    For example, if the rule is `self.a.b.c.d`, then when b is changed, we
+    unbind from `b`, `c` and `d`, if they were bound before (they were not
+    None and `rebind` of the respective properties was True) and we rebind
+    to the new values of the attrs `b`, `c``, `d` that are not None and
+    `rebind` is True.
+
+    :Parameters:
+        `base`
+            A (proxied) ref to the base widget, `self` in the example
+            above.
+        `keys`
+            A list of the name off the attrs of `base` being watched. In
+            the example above it'd be `['a', 'b', 'c', 'd']`.
+        `bound`
+            A list 4-tuples, each tuple being (widget, attr, callback, uid)
+            representing callback functions bound to the attributed `attr`
+            of `widget`. `uid` is returned by `fbind` when binding.
+            The callback may be None, in which case the attr
+            was not bound, but is there to be able to walk the attr tree.
+            E.g. in the example above, if `b` was not an eventdispatcher,
+            `(_b_ref_, `c`, None)` would be added to the list so we can get
+            to `c` and `d`, which may be eventdispatchers and their attrs.
+        `s`
+            The index in `keys` of the of the attr that needs to be
+            updated. That is all the keys from `s` and further will be
+            rebound, since the `s` key was changed. In bound, the
+            corresponding index is `s - 1`. If `s` is None, we start from
+            1 (first attr).
+        `fn`
+            The function to be called args, `args` on bound callback.
+    '''
+    # first remove all the old bound functions from `s` and down.
+    for f, k, fun, uid in bound[s:]:
+        if fun is None:
+            continue
+        try:
+            f.unbind_uid(k, uid)
+        except ReferenceError:
+            pass
+    del bound[s:]
+
+    # find the first attr from which we need to start rebinding.
+    f = getattr(*bound[-1][:2])
+    if f is None:
+        fn(args, None, None)
+        return
+    s += 1
+    append = bound.append
+
+    # bind all attrs, except last to update_intermediates
+    for val in keys[s:-1]:
+        # if we need to dynamically rebind, bindm otherwise just
+        # add the attr to the list
+        if isinstance(f, (EventDispatcher, Observable)):
+            prop = f.property(val, True)
+            if prop is not None and getattr(prop, 'rebind', False):
+                # fbind should not dispatch, otherwise
+                # update_intermediates might be called in the middle
+                # here messing things up
+                uid = f.fbind(
+                    val, update_intermediates, base, keys, bound, s, fn, args)
+                append([f.proxy_ref, val, update_intermediates, uid])
+            else:
+                append([f.proxy_ref, val, None, None])
+        else:
+            append([getattr(f, 'proxy_ref', f), val, None, None])
+
+        f = getattr(f, val, None)
+        if f is None:
+            break
+        s += 1
+
+    # for the last attr we bind directly to the setting function,
+    # because that attr sets the value of the rule.
+    if isinstance(f, (EventDispatcher, Observable)):
+        uid = f.fbind(keys[-1], fn, args)
+        if uid:
+            append([f.proxy_ref, keys[-1], fn, uid])
+    # when we rebind we have to update the
+    # rule with the most recent value, otherwise, the value might be wrong
+    # and wouldn't be updated since we might not have tracked it before.
+    # This only happens for a callback when rebind was True for the prop.
+    fn(args, None, None)
+
+
+def create_handler(iself, element, key, value, rule, idmap, delayed=False):
+    idmap = copy(idmap)
+    idmap.update(global_idmap)
+    idmap['self'] = iself.proxy_ref
+    bound_list = _handlers[iself.uid][key]
+    handler_append = bound_list.append
+
+    # we need a hash for when delayed, so we don't execute duplicate canvas
+    # callbacks from the same handler during a sync op
+    if delayed:
+        fn = delayed_call_fn
+        args = [element, key, value, rule, idmap, None]  # see _delayed_start
+    else:
+        fn = call_fn
+        args = (element, key, value, rule, idmap)
+
+    # bind every key.value
+    if rule.watched_keys is not None:
+        for keys in rule.watched_keys:
+            base = idmap.get(keys[0])
+            if base is None:
+                continue
+            f = base = getattr(base, 'proxy_ref', base)
+            bound = []
+            was_bound = False
+            append = bound.append
+
+            # bind all attrs, except last to update_intermediates
+            k = 1
+            for val in keys[1:-1]:
+                # if we need to dynamically rebind, bindm otherwise
+                # just add the attr to the list
+                if isinstance(f, (EventDispatcher, Observable)):
+                    prop = f.property(val, True)
+                    if prop is not None and getattr(prop, 'rebind', False):
+                        # fbind should not dispatch, otherwise
+                        # update_intermediates might be called in the middle
+                        # here messing things up
+                        uid = f.fbind(
+                            val, update_intermediates, base, keys, bound, k,
+                            fn, args)
+                        append([f.proxy_ref, val, update_intermediates, uid])
+                        was_bound = True
+                    else:
+                        append([f.proxy_ref, val, None, None])
+                elif not isinstance(f, type):
+                    append([getattr(f, 'proxy_ref', f), val, None, None])
+                else:
+                    append([f, val, None, None])
+                f = getattr(f, val, None)
+                if f is None:
+                    break
+                k += 1
+
+            # for the last attr we bind directly to the setting
+            # function, because that attr sets the value of the rule.
+            if isinstance(f, (EventDispatcher, Observable)):
+                uid = f.fbind(keys[-1], fn, args)  # f is not None
+                if uid:
+                    append([f.proxy_ref, keys[-1], fn, uid])
+                    was_bound = True
+            if was_bound:
+                handler_append(bound)
+
+    try:
+        return eval(value, idmap), bound_list
+    except Exception as e:
+        tb = sys.exc_info()[2]
+        raise BuilderException(rule.ctx, rule.line,
+                               '{}: {}'.format(e.__class__.__name__, e),
+                               cause=tb)
+
+
+class BuilderBase(object):
+    '''The Builder is responsible for creating a :class:`Parser` for parsing a
+    kv file, merging the results into its internal rules, templates, etc.
+
+    By default, :class:`Builder` is a global Kivy instance used in widgets
+    that you can use to load other kv files in addition to the default ones.
+    '''
+
+    def __init__(self):
+        super(BuilderBase, self).__init__()
+        self._match_cache = {}
+        self._match_name_cache = {}
+        self.files = []
+        self.dynamic_classes = {}
+        self.templates = {}
+        self.rules = []
+        self.rulectx = {}
+
+    @classmethod
+    def create_from(cls, builder):
+        """Creates a instance of the class, and initializes to the state of
+        ``builder``.
+
+        :param builder: The builder to initialize from.
+        :return: A new instance of this class.
+        """
+        obj = cls()
+        obj._match_cache = copy(builder._match_cache)
+        obj._match_name_cache = copy(builder._match_name_cache)
+        obj.files = copy(builder.files)
+        obj.dynamic_classes = copy(builder.dynamic_classes)
+        obj.templates = copy(builder.templates)
+        obj.rules = list(builder.rules)
+        assert not builder.rulectx
+        obj.rulectx = dict(builder.rulectx)
+
+        return obj
+
+    def load_file(self, filename, encoding='utf8', **kwargs):
+        '''Insert a file into the language builder and return the root widget
+        (if defined) of the kv file.
+
+        :parameters:
+            `rulesonly`: bool, defaults to False
+                If True, the Builder will raise an exception if you have a root
+                widget inside the definition.
+
+            `encoding`: File character encoding. Defaults to utf-8,
+        '''
+
+        filename = resource_find(filename) or filename
+        if __debug__:
+            trace('Lang: load file %s, using %s encoding', filename, encoding)
+
+        kwargs['filename'] = filename
+        with open(filename, 'r', encoding=encoding) as fd:
+            data = fd.read()
+            return self.load_string(data, **kwargs)
+
+    def unload_file(self, filename):
+        '''Unload all rules associated with a previously imported file.
+
+        .. versionadded:: 1.0.8
+
+        .. warning::
+
+            This will not remove rules or templates already applied/used on
+            current widgets. It will only effect the next widgets creation or
+            template invocation.
+        '''
+        # remove rules and templates
+        filename = resource_find(filename) or filename
+        self.rules = [x for x in self.rules if x[1].ctx.filename != filename]
+        self._clear_matchcache()
+        templates = {}
+        for x, y in self.templates.items():
+            if y[2] != filename:
+                templates[x] = y
+        self.templates = templates
+
+        if filename in self.files:
+            self.files.remove(filename)
+
+        # unregister all the dynamic classes
+        Factory.unregister_from_filename(filename)
+
+    def load_string(self, string, **kwargs):
+        '''Insert a string into the Language Builder and return the root widget
+        (if defined) of the kv string.
+
+        :Parameters:
+            `rulesonly`: bool, defaults to False
+                If True, the Builder will raise an exception if you have a root
+                widget inside the definition.
+            `filename`: str, defaults to None
+                If specified, the filename used to index the kv rules.
+
+        The filename parameter can be used to unload kv strings in the same way
+        as you unload kv files. This can be achieved using pseudo file names
+        e.g.::
+
+            Build.load_string("""
+                <MyRule>:
+                    Label:
+                        text="Hello"
+            """, filename="myrule.kv")
+
+        can be unloaded via::
+
+            Build.unload_file("myrule.kv")
+
+        '''
+
+        kwargs.setdefault('rulesonly', False)
+        self._current_filename = fn = kwargs.get('filename', None)
+
+        # put a warning if a file is loaded multiple times
+        if fn in self.files:
+            Logger.warning(
+                'Lang: The file {} is loaded multiples times, '
+                'you might have unwanted behaviors.'.format(fn))
+
+        try:
+            # parse the string
+            parser = Parser(content=string, filename=fn)
+
+            # merge rules with our rules
+            self.rules.extend(parser.rules)
+            self._clear_matchcache()
+
+            # add the template found by the parser into ours
+            for name, cls, template in parser.templates:
+                self.templates[name] = (cls, template, fn)
+                Factory.register(name,
+                                 cls=partial(self.template, name),
+                                 is_template=True, warn=True)
+
+            # register all the dynamic classes
+            for name, baseclasses in parser.dynamic_classes.items():
+                Factory.register(name, baseclasses=baseclasses, filename=fn,
+                                 warn=True)
+
+            # create root object is exist
+            if kwargs['rulesonly'] and parser.root:
+                filename = kwargs.get('rulesonly', '<string>')
+                raise Exception('The file <%s> contain also non-rules '
+                                'directives' % filename)
+
+            # save the loaded files only if there is a root without
+            # template/dynamic classes
+            if fn and (parser.templates or
+                       parser.dynamic_classes or parser.rules):
+                self.files.append(fn)
+
+            if parser.root:
+                widget = Factory.get(parser.root.name)(__no_builder=True)
+                rule_children = []
+                widget.apply_class_lang_rules(
+                    root=widget, rule_children=rule_children)
+                self._apply_rule(
+                    widget, parser.root, parser.root,
+                    rule_children=rule_children)
+
+                for child in rule_children:
+                    child.dispatch('on_kv_post', widget)
+                widget.dispatch('on_kv_post', widget)
+                return widget
+        finally:
+            self._current_filename = None
+
+    def template(self, *args, **ctx):
+        '''Create a specialized template using a specific context.
+
+        .. versionadded:: 1.0.5
+
+        With templates, you can construct custom widgets from a kv lang
+        definition by giving them a context. Check :ref:`Template usage
+        <template_usage>`.
+        '''
+        # Prevent naming clash with whatever the user might be putting into the
+        # ctx as key.
+        name = args[0]
+        if name not in self.templates:
+            raise Exception('Unknown <%s> template name' % name)
+        baseclasses, rule, fn = self.templates[name]
+        key = '%s|%s' % (name, baseclasses)
+        cls = Cache.get('kv.lang', key)
+        if cls is None:
+            rootwidgets = []
+            for basecls in baseclasses.split('+'):
+                rootwidgets.append(Factory.get(basecls))
+            cls = type(name, tuple(rootwidgets), {})
+            Cache.append('kv.lang', key, cls)
+        widget = cls()
+        # in previous versions, ``ctx`` is passed as is as ``template_ctx``
+        # preventing widgets in it from be collected by the GC. This was
+        # especially relevant to AccordionItem's title_template.
+        proxy_ctx = {k: get_proxy(v) for k, v in ctx.items()}
+        self._apply_rule(widget, rule, rule, template_ctx=proxy_ctx)
+        return widget
+
+    def apply_rules(
+            self, widget, rule_name, ignored_consts=set(), rule_children=None,
+            dispatch_kv_post=False):
+        '''Search all the rules that match the name `rule_name`
+        and apply them to `widget`.
+
+        .. versionadded:: 1.10.0
+
+        :Parameters:
+
+            `widget`: :class:`~kivy.uix.widget.Widget`
+                The widget to whom the matching rules should be applied to.
+            `ignored_consts`: set
+                A set or list type whose elements are property names for which
+                constant KV rules (i.e. those that don't create bindings) of
+                that widget will not be applied. This allows e.g. skipping
+                constant rules that overwrite a value initialized in python.
+            `rule_children`: list
+                If not ``None``, it should be a list that will be populated
+                with all the widgets created by the kv rules being applied.
+
+                .. versionchanged:: 1.11.0
+
+            `dispatch_kv_post`: bool
+                Normally the class `Widget` dispatches the `on_kv_post` event
+                to widgets created during kv rule application.
+                But if the rules are manually applied by calling :meth:`apply`,
+                that may not happen, so if this is `True`, we will dispatch the
+                `on_kv_post` event where needed after applying the rules to
+                `widget` (we won't dispatch it for `widget` itself).
+
+                Defaults to False.
+
+                .. versionchanged:: 1.11.0
+        '''
+        rules = self.match_rule_name(rule_name)
+        if __debug__:
+            trace('Lang: Found %d rules for %s' % (len(rules), rule_name))
+        if not rules:
+            return
+
+        if dispatch_kv_post:
+            rule_children = rule_children if rule_children is not None else []
+        for rule in rules:
+            self._apply_rule(
+                widget, rule, rule, ignored_consts=ignored_consts,
+                rule_children=rule_children)
+        if dispatch_kv_post:
+            for w in rule_children:
+                w.dispatch('on_kv_post', widget)
+
+    def apply(self, widget, ignored_consts=set(), rule_children=None,
+              dispatch_kv_post=False):
+        '''Search all the rules that match the widget and apply them.
+
+        :Parameters:
+
+            `widget`: :class:`~kivy.uix.widget.Widget`
+                The widget whose class rules should be applied to this widget.
+            `ignored_consts`: set
+                A set or list type whose elements are property names for which
+                constant KV rules (i.e. those that don't create bindings) of
+                that widget will not be applied. This allows e.g. skipping
+                constant rules that overwrite a value initialized in python.
+            `rule_children`: list
+                If not ``None``, it should be a list that will be populated
+                with all the widgets created by the kv rules being applied.
+
+                .. versionchanged:: 1.11.0
+
+            `dispatch_kv_post`: bool
+                Normally the class `Widget` dispatches the `on_kv_post` event
+                to widgets created during kv rule application.
+                But if the rules are manually applied by calling :meth:`apply`,
+                that may not happen, so if this is `True`, we will dispatch the
+                `on_kv_post` event where needed after applying the rules to
+                `widget` (we won't dispatch it for `widget` itself).
+
+                Defaults to False.
+
+                .. versionchanged:: 1.11.0
+        '''
+        rules = self.match(widget)
+        if __debug__:
+            trace('Lang: Found %d rules for %s' % (len(rules), widget))
+        if not rules:
+            return
+
+        if dispatch_kv_post:
+            rule_children = rule_children if rule_children is not None else []
+        for rule in rules:
+            self._apply_rule(
+                widget, rule, rule, ignored_consts=ignored_consts,
+                rule_children=rule_children)
+        if dispatch_kv_post:
+            for w in rule_children:
+                w.dispatch('on_kv_post', widget)
+
+    def _clear_matchcache(self):
+        self._match_cache.clear()
+        self._match_name_cache.clear()
+
+    def _apply_rule(self, widget, rule, rootrule, template_ctx=None,
+                    ignored_consts=set(), rule_children=None):
+        # widget: the current instantiated widget
+        # rule: the current rule
+        # rootrule: the current root rule (for children of a rule)
+
+        # will collect reference to all the id in children
+        assert(rule not in self.rulectx)
+        self.rulectx[rule] = rctx = {
+            'ids': {'root': widget.proxy_ref},
+            'set': [], 'hdl': []}
+
+        # extract the context of the rootrule (not rule!)
+        assert(rootrule in self.rulectx)
+        rctx = self.rulectx[rootrule]
+
+        # if a template context is passed, put it as "ctx"
+        if template_ctx is not None:
+            rctx['ids']['ctx'] = QueryDict(template_ctx)
+
+        # if we got an id, put it in the root rule for a later global usage
+        if rule.id:
+            # use only the first word as `id` discard the rest.
+            rule.id = rule.id.split('#', 1)[0].strip()
+            rctx['ids'][rule.id] = widget.proxy_ref
+            # set id name as a attribute for root widget so one can in python
+            # code simply access root_widget.id_name
+            _ids = dict(rctx['ids'])
+            _root = _ids.pop('root')
+            _new_ids = _root.ids
+            for _key, _value in _ids.items():
+                if _value == _root:
+                    # skip on self
+                    continue
+                _new_ids[_key] = _value
+            _root.ids = _new_ids
+
+        # first, ensure that the widget have all the properties used in
+        # the rule if not, they will be created as ObjectProperty.
+        rule.create_missing(widget)
+
+        # build the widget canvas
+        if rule.canvas_before:
+            with widget.canvas.before:
+                self._build_canvas(widget.canvas.before, widget,
+                                   rule.canvas_before, rootrule)
+        if rule.canvas_root:
+            with widget.canvas:
+                self._build_canvas(widget.canvas, widget,
+                                   rule.canvas_root, rootrule)
+        if rule.canvas_after:
+            with widget.canvas.after:
+                self._build_canvas(widget.canvas.after, widget,
+                                   rule.canvas_after, rootrule)
+
+        # create children tree
+        Factory_get = Factory.get
+        Factory_is_template = Factory.is_template
+        for crule in rule.children:
+            cname = crule.name
+
+            if cname in ('canvas', 'canvas.before', 'canvas.after'):
+                raise ParserException(
+                    crule.ctx, crule.line,
+                    'Canvas instructions added in kv must '
+                    'be declared before child widgets.')
+
+            # depending if the child rule is a template or not, we are not
+            # having the same approach
+            cls = Factory_get(cname)
+
+            if Factory_is_template(cname):
+                # we got a template, so extract all the properties and
+                # handlers, and push them in a "ctx" dictionary.
+                ctx = {}
+                idmap = copy(global_idmap)
+                idmap.update({'root': rctx['ids']['root']})
+                if 'ctx' in rctx['ids']:
+                    idmap.update({'ctx': rctx['ids']['ctx']})
+                try:
+                    for prule in crule.properties.values():
+                        value = prule.co_value
+                        if type(value) is CodeType:
+                            value = eval(value, idmap)
+                        ctx[prule.name] = value
+                    for prule in crule.handlers:
+                        value = eval(prule.value, idmap)
+                        ctx[prule.name] = value
+                except Exception as e:
+                    tb = sys.exc_info()[2]
+                    raise BuilderException(
+                        prule.ctx, prule.line,
+                        '{}: {}'.format(e.__class__.__name__, e), cause=tb)
+
+                # create the template with an explicit ctx
+                child = cls(**ctx)
+                widget.add_widget(child)
+
+                # reference it on our root rule context
+                if crule.id:
+                    rctx['ids'][crule.id] = child
+
+            else:
+                # we got a "normal" rule, construct it manually
+                # we can't construct it without __no_builder=True, because the
+                # previous implementation was doing the add_widget() before
+                # apply(), and so, we could use "self.parent".
+                child = cls(__no_builder=True)
+                widget.add_widget(child)
+                child.apply_class_lang_rules(
+                    root=rctx['ids']['root'], rule_children=rule_children)
+                self._apply_rule(
+                    child, crule, rootrule, rule_children=rule_children)
+
+                if rule_children is not None:
+                    rule_children.append(child)
+
+        # append the properties and handlers to our final resolution task
+        if rule.properties:
+            rctx['set'].append((widget.proxy_ref,
+                                list(rule.properties.values())))
+            for key, crule in rule.properties.items():
+                # clear previously applied rules if asked
+                if crule.ignore_prev:
+                    Builder.unbind_property(widget, key)
+        if rule.handlers:
+            rctx['hdl'].append((widget.proxy_ref, rule.handlers))
+
+        # if we are applying another rule that the root one, then it's done for
+        # us!
+        if rootrule is not rule:
+            del self.rulectx[rule]
+            return
+
+        # normally, we can apply a list of properties with a proper context
+        try:
+            rule = None
+            for widget_set, rules in reversed(rctx['set']):
+                for rule in rules:
+                    assert(isinstance(rule, ParserRuleProperty))
+                    key = rule.name
+                    value = rule.co_value
+                    if type(value) is CodeType:
+                        value, bound = create_handler(
+                            widget_set, widget_set, key, value, rule,
+                            rctx['ids'])
+                        # if there's a rule
+                        if (widget_set != widget or bound or
+                                key not in ignored_consts):
+                            setattr(widget_set, key, value)
+                    else:
+                        if (widget_set != widget or
+                                key not in ignored_consts):
+                            setattr(widget_set, key, value)
+
+        except Exception as e:
+            if rule is not None:
+                tb = sys.exc_info()[2]
+                raise BuilderException(rule.ctx, rule.line,
+                                       '{}: {}'.format(e.__class__.__name__,
+                                                       e), cause=tb)
+            raise e
+
+        # build handlers
+        try:
+            crule = None
+            for widget_set, rules in rctx['hdl']:
+                for crule in rules:
+                    assert(isinstance(crule, ParserRuleProperty))
+                    assert(crule.name.startswith('on_'))
+                    key = crule.name
+                    if not widget_set.is_event_type(key):
+                        key = key[3:]
+                    idmap = copy(global_idmap)
+                    idmap.update(rctx['ids'])
+                    idmap['self'] = widget_set.proxy_ref
+                    if not widget_set.fbind(key, custom_callback, crule,
+                                            idmap):
+                        raise AttributeError(key)
+                    # hack for on_parent
+                    if crule.name == 'on_parent':
+                        Factory.Widget.parent.dispatch(widget_set.__self__)
+        except Exception as e:
+            if crule is not None:
+                tb = sys.exc_info()[2]
+                raise BuilderException(
+                    crule.ctx, crule.line,
+                    '{}: {}'.format(e.__class__.__name__, e), cause=tb)
+            raise e
+
+        # rule finished, forget it
+        del self.rulectx[rootrule]
+
+    def match(self, widget):
+        '''Return a list of :class:`ParserRule` objects matching the widget.
+        '''
+        cache = self._match_cache
+        k = (widget.__class__, tuple(widget.cls))
+        if k in cache:
+            return cache[k]
+        rules = []
+        for selector, rule in self.rules:
+            if selector.match(widget):
+                if rule.avoid_previous_rules:
+                    del rules[:]
+                rules.append(rule)
+        cache[k] = rules
+        return rules
+
+    def match_rule_name(self, rule_name):
+        '''Return a list of :class:`ParserRule` objects matching the widget.
+        '''
+        cache = self._match_name_cache
+        rule_name = str(rule_name)
+        k = rule_name.lower()
+        if k in cache:
+            return cache[k]
+        rules = []
+        for selector, rule in self.rules:
+            if selector.match_rule_name(rule_name):
+                if rule.avoid_previous_rules:
+                    del rules[:]
+                rules.append(rule)
+        cache[k] = rules
+        return rules
+
+    def sync(self):
+        '''Execute all the waiting operations, such as the execution of all the
+        expressions related to the canvas.
+
+        .. versionadded:: 1.7.0
+        '''
+        global _delayed_start
+        next_args = _delayed_start
+        if next_args is None:
+            return
+
+        while next_args is not StopIteration:
+            # is this try/except still needed? yes, in case widget died in this
+            # frame after the call was scheduled
+            try:
+                call_fn(next_args[:-1], None, None)
+            except ReferenceError:
+                pass
+            args = next_args
+            next_args = args[-1]
+            args[-1] = None
+        _delayed_start = None
+
+    def unbind_widget(self, uid):
+        '''Unbind all the handlers created by the KV rules of the
+        widget. The :attr:`kivy.uix.widget.Widget.uid` is passed here
+        instead of the widget itself, because Builder is using it in the
+        widget destructor.
+
+        This effectively clears all the KV rules associated with this widget.
+        For example:
+
+        .. code-block:: python
+
+            >>> 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]
+
+        .. versionadded:: 1.7.2
+        '''
+        if uid not in _handlers:
+            return
+        for prop_callbacks in _handlers[uid].values():
+            for callbacks in prop_callbacks:
+                for f, k, fn, bound_uid in callbacks:
+                    if fn is None:  # it's not a kivy prop.
+                        continue
+                    try:
+                        f.unbind_uid(k, bound_uid)
+                    except ReferenceError:
+                        # proxy widget is already gone, that's cool :)
+                        pass
+        del _handlers[uid]
+
+    def unbind_property(self, widget, name):
+        '''Unbind the handlers created by all the rules of the widget that set
+        the name.
+
+        This effectively clears all the rules of widget that take the form::
+
+            name: rule
+
+        For example:
+
+        .. code-block:: python
+
+            >>> 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]
+
+        .. versionadded:: 1.9.1
+        '''
+        uid = widget.uid
+        if uid not in _handlers:
+            return
+
+        prop_handlers = _handlers[uid]
+        if name not in prop_handlers:
+            return
+
+        for callbacks in prop_handlers[name]:
+            for f, k, fn, bound_uid in callbacks:
+                if fn is None:  # it's not a kivy prop.
+                    continue
+                try:
+                    f.unbind_uid(k, bound_uid)
+                except ReferenceError:
+                    # proxy widget is already gone, that's cool :)
+                    pass
+        del prop_handlers[name]
+        if not prop_handlers:
+            del _handlers[uid]
+
+    def _build_canvas(self, canvas, widget, rule, rootrule):
+        global Instruction
+        if Instruction is None:
+            Instruction = Factory.get('Instruction')
+        idmap = copy(self.rulectx[rootrule]['ids'])
+        for crule in rule.children:
+            name = crule.name
+            if name == 'Clear':
+                canvas.clear()
+                continue
+            instr = Factory.get(name)()
+            if not isinstance(instr, Instruction):
+                raise BuilderException(
+                    crule.ctx, crule.line,
+                    'You can add only graphics Instruction in canvas.')
+            try:
+                for prule in crule.properties.values():
+                    key = prule.name
+                    value = prule.co_value
+                    if type(value) is CodeType:
+                        value, _ = create_handler(
+                            widget, instr.proxy_ref,
+                            key, value, prule, idmap, True)
+                    setattr(instr, key, value)
+            except Exception as e:
+                tb = sys.exc_info()[2]
+                raise BuilderException(
+                    prule.ctx, prule.line,
+                    '{}: {}'.format(e.__class__.__name__, e), cause=tb)
+
+
+#: Main instance of a :class:`BuilderBase`.
+Builder: BuilderBase = register_context('Builder', BuilderBase)
+Builder.load_file(join(kivy_data_dir, 'style.kv'), rulesonly=True)
+
+if 'KIVY_PROFILE_LANG' in environ:
+    import atexit
+    from html import escape
+
+    def match_rule(fn, index, rule):
+        if rule.ctx.filename != fn:
+            return
+        for prop, prp in rule.properties.items():
+            if prp.line != index:
+                continue
+            yield prp
+        for child in rule.children:
+            for r in match_rule(fn, index, child):
+                yield r
+        if rule.canvas_root:
+            for r in match_rule(fn, index, rule.canvas_root):
+                yield r
+        if rule.canvas_before:
+            for r in match_rule(fn, index, rule.canvas_before):
+                yield r
+        if rule.canvas_after:
+            for r in match_rule(fn, index, rule.canvas_after):
+                yield r
+
+    def dump_builder_stats():
+        html = [
+            '<!doctype html>'
+            '<html><body>',
+            '<style type="text/css">\n',
+            'pre { margin: 0; }\n',
+            '</style>']
+        files = {x[1].ctx.filename for x in Builder.rules}
+        for fn in files:
+            try:
+                with open(fn) as f:
+                    lines = f.readlines()
+            except (IOError, TypeError) as e:
+                continue
+            html += ['<h2>', fn, '</h2>', '<table>']
+            count = 0
+            for index, line in enumerate(lines):
+                line = line.rstrip()
+                line = escape(line)
+                matched_prp = []
+                for psn, rule in Builder.rules:
+                    matched_prp.extend(match_rule(fn, index, rule))
+
+                count = sum({x.count for x in matched_prp})
+
+                color = (255, 155, 155) if count else (255, 255, 255)
+                html += ['<tr style="background-color: rgb{}">'.format(color),
+                         '<td>', str(index + 1), '</td>',
+                         '<td>', str(count), '</td>',
+                         '<td><pre>', line, '</pre></td>',
+                         '</tr>']
+            html += ['</table>']
+        html += ['</body></html>']
+        with open('builder_stats.html', 'w', encoding='utf-8') as fd:
+            fd.write(''.join(html))
+
+        print('Profiling written at builder_stats.html')
+
+    atexit.register(dump_builder_stats)
diff --git a/kivy/lang/parser.py b/kivy/lang/parser.py
new file mode 100644
index 0000000..e31afea
--- /dev/null
+++ b/kivy/lang/parser.py
@@ -0,0 +1,817 @@
+'''
+Parser
+======
+
+Class used for the parsing of .kv files into rules.
+'''
+import os
+
+import re
+import sys
+import traceback
+import ast
+import importlib
+from re import sub, findall
+from types import CodeType
+from functools import partial
+from collections import OrderedDict, defaultdict
+
+import kivy.lang.builder  # imported as absolute to avoid circular import
+from kivy.logger import Logger
+from kivy.cache import Cache
+from kivy import require
+from kivy.resources import resource_find
+from kivy.utils import rgba
+import kivy.metrics as Metrics
+
+__all__ = ('Parser', 'ParserException')
+
+
+trace = Logger.trace
+global_idmap = {}
+
+# register cache for creating new classtype (template)
+Cache.register('kv.lang')
+
+# all previously included files
+__KV_INCLUDES__ = []
+
+# precompile regexp expression
+str_re = (
+    "(?:'''.*?''')|"
+    "(?:(?:(?<!')|''')'(?:[^']|\\\\')+?'(?:(?!')|'''))|"
+    '(?:""".*?""")|'
+    '(?:(?:(?<!")|""")"(?:[^"]|\\\\")+?"(?:(?!")|"""))'
+)
+
+lang_str = re.compile(f"({str_re})", re.DOTALL)
+lang_fstr = re.compile(f"([fF](?:{str_re}))", re.DOTALL)
+
+lang_key = re.compile('([a-zA-Z_]+)')
+lang_keyvalue = re.compile(r'([a-zA-Z_][a-zA-Z0-9_.]*\.[a-zA-Z0-9_.]+)')
+lang_tr = re.compile(r'(_\()')
+lang_cls_split_pat = re.compile(', *')
+
+# all the widget handlers, used to correctly unbind all the callbacks then the
+# widget is deleted
+_handlers = defaultdict(partial(defaultdict, list))
+
+
+class ProxyApp(object):
+    # proxy app object
+    # taken from http://code.activestate.com/recipes/496741-object-proxying/
+
+    __slots__ = ['_obj']
+
+    def __init__(self):
+        object.__init__(self)
+        object.__setattr__(self, '_obj', None)
+
+    def _ensure_app(self):
+        app = object.__getattribute__(self, '_obj')
+        if app is None:
+            from kivy.app import App
+            app = App.get_running_app()
+            object.__setattr__(self, '_obj', app)
+            # Clear cached application instance, when it stops
+            app.bind(on_stop=lambda instance:
+                     object.__setattr__(self, '_obj', None))
+        return app
+
+    def __getattribute__(self, name):
+        object.__getattribute__(self, '_ensure_app')()
+        return getattr(object.__getattribute__(self, '_obj'), name)
+
+    def __delattr__(self, name):
+        object.__getattribute__(self, '_ensure_app')()
+        delattr(object.__getattribute__(self, '_obj'), name)
+
+    def __setattr__(self, name, value):
+        object.__getattribute__(self, '_ensure_app')()
+        setattr(object.__getattribute__(self, '_obj'), name, value)
+
+    def __bool__(self):
+        object.__getattribute__(self, '_ensure_app')()
+        return bool(object.__getattribute__(self, '_obj'))
+
+    def __str__(self):
+        object.__getattribute__(self, '_ensure_app')()
+        return str(object.__getattribute__(self, '_obj'))
+
+    def __repr__(self):
+        object.__getattribute__(self, '_ensure_app')()
+        return repr(object.__getattribute__(self, '_obj'))
+
+
+global_idmap['app'] = ProxyApp()
+global_idmap['pt'] = Metrics.pt
+global_idmap['inch'] = Metrics.inch
+global_idmap['cm'] = Metrics.cm
+global_idmap['mm'] = Metrics.mm
+global_idmap['dp'] = Metrics.dp
+global_idmap['sp'] = Metrics.sp
+global_idmap['rgba'] = rgba
+
+
+class ParserException(Exception):
+    '''Exception raised when something wrong happened in a kv file.
+    '''
+
+    def __init__(self, context, line, message, cause=None):
+        self.filename = context.filename or '<inline>'
+        self.line = line
+        sourcecode = context.sourcecode
+        sc_start = max(0, line - 2)
+        sc_stop = min(len(sourcecode), line + 3)
+        sc = ['...']
+        for x in range(sc_start, sc_stop):
+            if x == line:
+                sc += ['>> %4d:%s' % (line + 1, sourcecode[line][1])]
+            else:
+                sc += ['   %4d:%s' % (x + 1, sourcecode[x][1])]
+        sc += ['...']
+        sc = '\n'.join(sc)
+
+        message = 'Parser: File "%s", line %d:\n%s\n%s' % (
+            self.filename, self.line + 1, sc, message)
+        if cause:
+            message += '\n' + ''.join(traceback.format_tb(cause))
+
+        super(ParserException, self).__init__(message)
+
+
+class ParserRuleProperty(object):
+    '''Represent a property inside a rule.
+    '''
+
+    __slots__ = ('ctx', 'line', 'name', 'value', 'co_value',
+                 'watched_keys', 'mode', 'count', 'ignore_prev')
+
+    def __init__(self, ctx, line, name, value, ignore_prev=False):
+        super(ParserRuleProperty, self).__init__()
+        #: Associated parser
+        self.ctx = ctx
+        #: Line of the rule
+        self.line = line
+        #: Name of the property
+        self.name = name
+        #: Value of the property
+        self.value = value
+        #: Compiled value
+        self.co_value = None
+        #: Compilation mode
+        self.mode = None
+        #: Watched keys
+        self.watched_keys = None
+        #: Stats
+        self.count = 0
+        #: whether previous rules targeting name should be cleared
+        self.ignore_prev = ignore_prev
+
+    def precompile(self):
+        name = self.name
+        value = self.value
+
+        # first, remove all the string from the value
+        tmp = sub(lang_str, '', self.value)
+
+        # detecting how to handle the value according to the key name
+        mode = self.mode
+        if self.mode is None:
+            self.mode = mode = 'exec' if name[:3] == 'on_' else 'eval'
+        if mode == 'eval':
+            # if we don't detect any string/key in it, we can eval and give the
+            # result
+            if re.search(lang_key, tmp) is None:
+                value = '\n' * self.line + value
+                self.co_value = eval(
+                    compile(value, self.ctx.filename or '<string>', 'eval')
+                )
+                return
+
+        # ok, we can compile.
+        value = '\n' * self.line + value
+        self.co_value = compile(value, self.ctx.filename or '<string>', mode)
+
+        # for exec mode, we don't need to watch any keys.
+        if mode == 'exec':
+            return
+
+        # now, detect obj.prop
+        # find all the fstrings in the  value
+        fstrings = lang_fstr.findall(value)
+        wk = set()
+        for s in fstrings:
+            expression = ast.parse(s)
+            wk |= set(self.get_names_from_expression(expression.body[0].value))
+
+        # first, remove all the string from the value
+        tmp = sub(lang_str, '', value)
+        idx = tmp.find('#')
+        if idx != -1:
+            tmp = tmp[:idx]
+        # detect key.value inside value, and split them
+        wk |= set(findall(lang_keyvalue, tmp))
+        if wk:
+            self.watched_keys = [x.split('.') for x in wk]
+        if findall(lang_tr, tmp):
+            if self.watched_keys:
+                self.watched_keys += [['_']]
+            else:
+                self.watched_keys = [['_']]
+
+    @classmethod
+    def get_names_from_expression(cls, node):
+        """
+        Look for all the symbols used in an ast node.
+        """
+        if isinstance(node, ast.Name):
+            yield node.id
+
+        if isinstance(node, (ast.JoinedStr, ast.BoolOp)):
+            for n in node.values:
+                if isinstance(n, ast.Str):
+                    # NOTE: required for python3.6
+                    yield from cls.get_names_from_expression(n.s)
+                else:
+                    yield from cls.get_names_from_expression(n.value)
+
+        if isinstance(node, ast.BinOp):
+            yield from cls.get_names_from_expression(node.right)
+            yield from cls.get_names_from_expression(node.left)
+
+        if isinstance(node, ast.IfExp):
+            yield from cls.get_names_from_expression(node.test)
+            yield from cls.get_names_from_expression(node.body)
+            yield from cls.get_names_from_expression(node.orelse)
+
+        if isinstance(node, ast.Subscript):
+            yield from cls.get_names_from_expression(node.value)
+            yield from cls.get_names_from_expression(node.slice)
+
+        if isinstance(node, ast.Slice):
+            yield from cls.get_names_from_expression(node.lower)
+            yield from cls.get_names_from_expression(node.upper)
+            yield from cls.get_names_from_expression(node.step)
+
+        if isinstance(
+            node,
+            (ast.ListComp, ast.DictComp, ast.SetComp, ast.GeneratorExp)
+        ):
+            for g in node.generators:
+                yield from cls.get_names_from_expression(g.iter)
+
+        if isinstance(node, (ast.List, ast.Tuple, ast.Set)):
+            for elt in node.elts:
+                yield from cls.get_names_from_expression(elt)
+
+        if isinstance(node, ast.Dict):
+            for val in node.values:
+                yield from cls.get_names_from_expression(val)
+
+        if isinstance(node, ast.UnaryOp):
+            yield from cls.get_names_from_expression(node.operand)
+
+        if isinstance(node, ast.comprehension):
+            yield from cls.get_names_from_expression(node.iter.value)
+
+        if isinstance(node, ast.Attribute):
+            if isinstance(node.value, ast.Name):
+                yield f'{node.value.id}.{node.attr}'
+
+        if isinstance(node, ast.Call):
+            yield from cls.get_names_from_expression(node.func)
+
+            for arg in node.args:
+                yield from cls.get_names_from_expression(arg)
+            for keyword in node.keywords:
+                yield from cls.get_names_from_expression(keyword.value)
+
+    def __repr__(self):
+        return '<ParserRuleProperty name=%r filename=%s:%d ' \
+               'value=%r watched_keys=%r>' % (
+                   self.name, self.ctx.filename, self.line + 1,
+                   self.value, self.watched_keys)
+
+
+class ParserRule(object):
+    '''Represents a rule, in terms of the Kivy internal language.
+    '''
+
+    __slots__ = ('ctx', 'line', 'name', 'children', 'id', 'properties',
+                 'canvas_before', 'canvas_root', 'canvas_after',
+                 'handlers', 'level', 'cache_marked', 'avoid_previous_rules')
+
+    def __init__(self, ctx, line, name, level):
+        super(ParserRule, self).__init__()
+        #: Level of the rule in the kv
+        self.level = level
+        #: Associated parser
+        self.ctx = ctx
+        #: Line of the rule
+        self.line = line
+        #: Name of the rule
+        self.name = name
+        #: List of children to create
+        self.children = []
+        #: Id given to the rule
+        self.id = None
+        #: Properties associated to the rule
+        self.properties = OrderedDict()
+        #: Canvas normal
+        self.canvas_root = None
+        #: Canvas before
+        self.canvas_before = None
+        #: Canvas after
+        self.canvas_after = None
+        #: Handlers associated to the rule
+        self.handlers = []
+        #: Properties cache list: mark which class have already been checked
+        self.cache_marked = []
+        #: Indicate if any previous rules should be avoided.
+        self.avoid_previous_rules = False
+
+        if level == 0:
+            self._detect_selectors()
+        else:
+            self._forbid_selectors()
+
+    def precompile(self):
+        for x in self.properties.values():
+            x.precompile()
+        for x in self.handlers:
+            x.precompile()
+        for x in self.children:
+            x.precompile()
+        if self.canvas_before:
+            self.canvas_before.precompile()
+        if self.canvas_root:
+            self.canvas_root.precompile()
+        if self.canvas_after:
+            self.canvas_after.precompile()
+
+    def create_missing(self, widget):
+        # check first if the widget class already been processed by this rule
+        cls = widget.__class__
+        if cls in self.cache_marked:
+            return
+        self.cache_marked.append(cls)
+        for name in self.properties:
+            if hasattr(widget, name):
+                continue
+            value = self.properties[name].co_value
+            if type(value) is CodeType:
+                value = None
+            widget.create_property(name, value, default_value=False)
+
+    def _forbid_selectors(self):
+        c = self.name[0]
+        if c == '<' or c == '[':
+            raise ParserException(
+                self.ctx, self.line,
+                'Selectors rules are allowed only at the first level')
+
+    def _detect_selectors(self):
+        c = self.name[0]
+        if c == '<':
+            self._build_rule()
+        elif c == '[':
+            self._build_template()
+        else:
+            if self.ctx.root is not None:
+                raise ParserException(
+                    self.ctx, self.line,
+                    'Only one root object is allowed by .kv')
+            self.ctx.root = self
+
+    def _build_rule(self):
+        name = self.name
+        if __debug__:
+            trace('Builder: build rule for %s' % name)
+        if name[0] != '<' or name[-1] != '>':
+            raise ParserException(self.ctx, self.line,
+                                  'Invalid rule (must be inside <>)')
+
+        # if the very first name start with a -, avoid previous rules
+        name = name[1:-1]
+        if name[:1] == '-':
+            self.avoid_previous_rules = True
+            name = name[1:]
+
+        for rule in re.split(lang_cls_split_pat, name):
+            crule = None
+
+            if not rule:
+                raise ParserException(self.ctx, self.line,
+                                      'Empty rule detected')
+
+            if '@' in rule:
+                # new class creation ?
+                # ensure the name is correctly written
+                rule, baseclasses = rule.split('@', 1)
+                if not re.match(lang_key, rule):
+                    raise ParserException(self.ctx, self.line,
+                                          'Invalid dynamic class name')
+
+                # save the name in the dynamic classes dict.
+                self.ctx.dynamic_classes[rule] = baseclasses
+                crule = ParserSelectorName(rule)
+
+            else:
+                # classical selectors.
+
+                if rule[0] == '.':
+                    crule = ParserSelectorClass(rule[1:])
+                else:
+                    crule = ParserSelectorName(rule)
+
+            self.ctx.rules.append((crule, self))
+
+    def _build_template(self):
+        name = self.name
+        exception = ParserException(
+            self.ctx, self.line,
+            'Deprecated Kivy lang template syntax used "{}". Templates will '
+            'be removed in a future version'.format(name))
+        if name not in ('[FileListEntry@FloatLayout+TreeViewNode]',
+                        '[FileIconEntry@Widget]',
+                        '[AccordionItemTitle@Label]'):
+            Logger.warning(exception)
+
+        if __debug__:
+            trace('Builder: build template for %s' % name)
+        if name[0] != '[' or name[-1] != ']':
+            raise ParserException(self.ctx, self.line,
+                                  'Invalid template (must be inside [])')
+        item_content = name[1:-1]
+        if '@' not in item_content:
+            raise ParserException(self.ctx, self.line,
+                                  'Invalid template name (missing @)')
+        template_name, template_root_cls = item_content.split('@')
+        self.ctx.templates.append((template_name, template_root_cls, self))
+
+    def __repr__(self):
+        return '<ParserRule name=%r>' % (self.name, )
+
+
+class Parser(object):
+    '''Create a Parser object to parse a Kivy language file or Kivy content.
+    '''
+
+    PROP_ALLOWED = ('canvas.before', 'canvas.after')
+    CLASS_RANGE = list(range(ord('A'), ord('Z') + 1))
+    PROP_RANGE = (
+        list(range(ord('A'), ord('Z') + 1)) +
+        list(range(ord('a'), ord('z') + 1)) +
+        list(range(ord('0'), ord('9') + 1)) + [ord('_')])
+
+    __slots__ = ('rules', 'templates', 'root', 'sourcecode',
+                 'directives', 'filename', 'dynamic_classes')
+
+    def __init__(self, **kwargs):
+        super(Parser, self).__init__()
+        self.rules = []
+        self.templates = []
+        self.root = None
+        self.sourcecode = []
+        self.directives = []
+        self.dynamic_classes = {}
+        self.filename = kwargs.get('filename', None)
+        content = kwargs.get('content', None)
+        if content is None:
+            raise ValueError('No content passed')
+        self.parse(content)
+
+    def execute_directives(self):
+        global __KV_INCLUDES__
+        for ln, cmd in self.directives:
+            cmd = cmd.strip()
+            if __debug__:
+                trace('Parser: got directive <%s>' % cmd)
+            if cmd[:5] == 'kivy ':
+                version = cmd[5:].strip()
+                if len(version.split('.')) == 2:
+                    version += '.0'
+                require(version)
+            elif cmd[:4] == 'set ':
+                try:
+                    name, value = cmd[4:].strip().split(' ', 1)
+                except:
+                    Logger.exception('')
+                    raise ParserException(self, ln, 'Invalid directive syntax')
+                try:
+                    value = eval(value, global_idmap)
+                except:
+                    Logger.exception('')
+                    raise ParserException(self, ln, 'Invalid value')
+                global_idmap[name] = value
+            elif cmd[:8] == 'include ':
+                ref = cmd[8:].strip()
+                force_load = False
+
+                if ref[:6] == 'force ':
+                    ref = ref[6:].strip()
+                    force_load = True
+
+                # if #:include [force] "path with quotes around"
+                if ref[0] == ref[-1] and ref[0] in ('"', "'"):
+                    c = ref[:3].count(ref[0])
+                    ref = ref[c:-c] if c != 2 else ref
+
+                if ref[-3:] != '.kv':
+                    Logger.warning('Lang: {0} does not have a valid Kivy'
+                                'Language extension (.kv)'.format(ref))
+                    break
+                if ref in __KV_INCLUDES__:
+                    if not os.path.isfile(resource_find(ref) or ref):
+                        raise ParserException(self, ln,
+                                              'Invalid or unknown file: {0}'
+                                              .format(ref))
+                    if not force_load:
+                        Logger.warning('Lang: {0} has already been included!'
+                                    .format(ref))
+                        continue
+                    else:
+                        Logger.debug('Lang: Reloading {0} '
+                                     'because include was forced.'
+                                     .format(ref))
+                        kivy.lang.builder.Builder.unload_file(ref)
+                        kivy.lang.builder.Builder.load_file(ref)
+                        continue
+                Logger.debug('Lang: Including file: {0}'.format(0))
+                __KV_INCLUDES__.append(ref)
+                kivy.lang.builder.Builder.load_file(ref)
+            elif cmd[:7] == 'import ':
+                package = cmd[7:].strip()
+                z = package.split()
+                if len(z) != 2:
+                    raise ParserException(self, ln, 'Invalid import syntax')
+                alias, package = z
+                try:
+                    if package not in sys.modules:
+                        try:
+                            mod = importlib.__import__(package)
+                        except ImportError:
+                            module_name = '.'.join(package.split('.')[:-1])
+                            mod = importlib.__import__(module_name)
+                        # resolve the whole thing
+                        for part in package.split('.')[1:]:
+                            mod = getattr(mod, part)
+                    else:
+                        mod = sys.modules[package]
+                    global_idmap[alias] = mod
+                except ImportError:
+                    Logger.exception('')
+                    raise ParserException(self, ln,
+                                          'Unable to import package %r' %
+                                          package)
+            else:
+                raise ParserException(self, ln, 'Unknown directive')
+
+    def parse(self, content):
+        '''Parse the contents of a Parser file and return a list
+        of root objects.
+        '''
+        # Read and parse the lines of the file
+        lines = content.splitlines()
+        if not lines:
+            return
+        num_lines = len(lines)
+        lines = list(zip(list(range(num_lines)), lines))
+        self.sourcecode = lines[:]
+
+        if __debug__:
+            trace('Parser: parsing %d lines' % num_lines)
+
+        # Strip all comments
+        self.strip_comments(lines)
+
+        # Execute directives
+        self.execute_directives()
+
+        # Get object from the first level
+        objects, remaining_lines = self.parse_level(0, lines)
+
+        # Precompile rules tree
+        for rule in objects:
+            rule.precompile()
+
+        # After parsing, there should be no remaining lines
+        # or there's an error we did not catch earlier.
+        if remaining_lines:
+            ln, content = remaining_lines[0]
+            raise ParserException(self, ln, 'Invalid data (not parsed)')
+
+    def strip_comments(self, lines):
+        '''Remove all comments from all lines in-place.
+           Comments need to be on a single line and not at the end of a line.
+           i.e. a comment line's first non-whitespace character must be a #.
+        '''
+        # extract directives
+        for ln, line in lines[:]:
+            stripped = line.strip()
+            if stripped[:2] == '#:':
+                self.directives.append((ln, stripped[2:]))
+            if stripped[:1] == '#':
+                lines.remove((ln, line))
+            if not stripped:
+                lines.remove((ln, line))
+
+    def parse_level(self, level, lines, spaces=0):
+        '''Parse the current level (level * spaces) indentation.
+        '''
+        indent = spaces * level if spaces > 0 else 0
+        objects = []
+
+        current_object = None
+        current_property = None
+        current_propobject = None
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            ln, content = line
+
+            # Get the number of space
+            tmp = content.lstrip(' \t')
+
+            # Replace any tab with 4 spaces
+            tmp = content[:len(content) - len(tmp)]
+            tmp = tmp.replace('\t', '    ')
+
+            # first indent designates the indentation
+            if spaces == 0:
+                spaces = len(tmp)
+
+            count = len(tmp)
+
+            if spaces > 0 and count % spaces != 0:
+                raise ParserException(self, ln,
+                                      'Invalid indentation, '
+                                      'must be a multiple of '
+                                      '%s spaces' % spaces)
+            content = content.strip()
+            rlevel = count // spaces if spaces > 0 else 0
+
+            # Level finished
+            if count < indent:
+                return objects, lines[i - 1:]
+
+            # Current level, create an object
+            elif count == indent:
+                x = content.split(':', 1)
+                if not x[0]:
+                    raise ParserException(self, ln, 'Identifier missing')
+                if (len(x) == 2 and len(x[1]) and
+                        not x[1].lstrip().startswith('#')):
+                    raise ParserException(self, ln,
+                                          'Invalid data after declaration')
+                name = x[0].rstrip()
+                # if it's not a root rule, then we got some restriction
+                # aka, a valid name, without point or everything else
+                if count != 0:
+                    if False in [ord(z) in Parser.PROP_RANGE for z in name]:
+                        raise ParserException(self, ln, 'Invalid class name')
+
+                current_object = ParserRule(self, ln, name, rlevel)
+                current_property = None
+                objects.append(current_object)
+
+            # Next level, is it a property or an object ?
+            elif count == indent + spaces:
+                x = content.split(':', 1)
+                if not x[0]:
+                    raise ParserException(self, ln, 'Identifier missing')
+
+                # It's a class, add to the current object as a children
+                current_property = None
+                name = x[0].rstrip()
+                ignore_prev = name[0] == '-'
+                if ignore_prev:
+                    name = name[1:]
+
+                if ord(name[0]) in Parser.CLASS_RANGE:
+                    if ignore_prev:
+                        raise ParserException(
+                            self, ln, 'clear previous, `-`, not allowed here')
+                    _objects, _lines = self.parse_level(
+                        level + 1, lines[i:], spaces)
+                    current_object.children = _objects
+                    lines = _lines
+                    i = 0
+
+                # It's a property
+                else:
+                    if name not in Parser.PROP_ALLOWED:
+                        if not all(ord(z) in Parser.PROP_RANGE for z in name):
+                            raise ParserException(self, ln,
+                                                  'Invalid property name')
+                    if len(x) == 1:
+                        raise ParserException(self, ln, 'Syntax error')
+                    value = x[1].strip()
+                    if name == 'id':
+                        if len(value) <= 0:
+                            raise ParserException(self, ln, 'Empty id')
+                        if value in ('self', 'root'):
+                            raise ParserException(
+                                self, ln,
+                                'Invalid id, cannot be "self" or "root"')
+                        current_object.id = value
+                    elif len(value):
+                        rule = ParserRuleProperty(
+                            self, ln, name, value, ignore_prev)
+                        if name[:3] == 'on_':
+                            current_object.handlers.append(rule)
+                        else:
+                            ignore_prev = False
+                            current_object.properties[name] = rule
+                    else:
+                        current_property = name
+                        current_propobject = None
+
+                    if ignore_prev:  # it wasn't consumed
+                        raise ParserException(
+                            self, ln, 'clear previous, `-`, not allowed here')
+
+            # Two more levels?
+            elif count == indent + 2 * spaces:
+                if current_property in (
+                        'canvas', 'canvas.after', 'canvas.before'):
+                    _objects, _lines = self.parse_level(
+                        level + 2, lines[i:], spaces)
+                    rl = ParserRule(self, ln, current_property, rlevel)
+                    rl.children = _objects
+                    if current_property == 'canvas':
+                        current_object.canvas_root = rl
+                    elif current_property == 'canvas.before':
+                        current_object.canvas_before = rl
+                    else:
+                        current_object.canvas_after = rl
+                    current_property = None
+                    lines = _lines
+                    i = 0
+                else:
+                    if current_propobject is None:
+                        current_propobject = ParserRuleProperty(
+                            self, ln, current_property, content)
+                        if current_property[:3] == 'on_':
+                            current_object.handlers.append(current_propobject)
+                        else:
+                            current_object.properties[current_property] = \
+                                current_propobject
+                    else:
+                        current_propobject.value += '\n' + content
+
+            # Too much indentation, invalid
+            else:
+                raise ParserException(self, ln,
+                                      'Invalid indentation (too many levels)')
+
+            # Check the next line
+            i += 1
+
+        return objects, []
+
+
+class ParserSelector(object):
+
+    def __init__(self, key):
+        self.key = key.lower()
+
+    def match(self, widget):
+        raise NotImplementedError
+
+    def __repr__(self):
+        return '<%s key=%s>' % (self.__class__.__name__, self.key)
+
+
+class ParserSelectorClass(ParserSelector):
+
+    def match(self, widget):
+        return self.key in widget.cls
+
+
+class ParserSelectorName(ParserSelector):
+
+    parents = {}
+
+    def get_bases(self, cls):
+        for base in cls.__bases__:
+            if base.__name__ == 'object':
+                break
+            yield base
+            if base.__name__ == 'Widget':
+                break
+            for cbase in self.get_bases(base):
+                yield cbase
+
+    def match(self, widget):
+        parents = ParserSelectorName.parents
+        cls = widget.__class__
+        if cls not in parents:
+            classes = [x.__name__.lower() for x in
+                       [cls] + list(self.get_bases(cls))]
+            parents[cls] = classes
+        return self.key in parents[cls]
+
+    def match_rule_name(self, rule_name):
+        return self.key == rule_name.lower()
diff --git a/kivy/lib/__init__.py b/kivy/lib/__init__.py
new file mode 100644
index 0000000..f99c263
--- /dev/null
+++ b/kivy/lib/__init__.py
@@ -0,0 +1,21 @@
+'''
+External libraries
+==================
+
+Kivy comes with other python/C libraries:
+
+* :mod:`~kivy.lib.ddsfile` - used for parsing and saving
+  `DDS <https://en.wikipedia.org/wiki/DirectDraw_Surface>`_ files.
+* :mod:`~kivy.lib.osc` - a modified/optimized version of PyOSC for using
+  the `Open Sound Control <https://en.wikipedia.org/wiki/Open_Sound_Control>`_
+  protocol.
+* :mod:`~kivy.lib.mtdev` - provides support for the
+  `Kernel multi-touch transformation library <https://launchpad.net/mtdev>`_.
+
+.. warning::
+
+    Even though Kivy comes with these external libraries, we do not provide any
+    support for them and they might change in the future.
+    Don't rely on them in your code.
+
+'''
diff --git a/kivy/lib/__pycache__/__init__.cpython-310.pyc b/kivy/lib/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..cacf185
Binary files /dev/null and b/kivy/lib/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/lib/__pycache__/ddsfile.cpython-310.pyc b/kivy/lib/__pycache__/ddsfile.cpython-310.pyc
new file mode 100644
index 0000000..d9a9c28
Binary files /dev/null and b/kivy/lib/__pycache__/ddsfile.cpython-310.pyc differ
diff --git a/kivy/lib/__pycache__/mtdev.cpython-310.pyc b/kivy/lib/__pycache__/mtdev.cpython-310.pyc
new file mode 100644
index 0000000..7629da6
Binary files /dev/null and b/kivy/lib/__pycache__/mtdev.cpython-310.pyc differ
diff --git a/kivy/lib/ddsfile.py b/kivy/lib/ddsfile.py
new file mode 100644
index 0000000..a367679
--- /dev/null
+++ b/kivy/lib/ddsfile.py
@@ -0,0 +1,419 @@
+'''
+DDS File library
+================
+
+This library can be used to parse and save DDS
+(`DirectDraw Surface <https://en.wikipedia.org/wiki/DirectDraw_Surface>`)
+files.
+
+The initial version was written by::
+
+    Alexey Borzenkov (snaury@gmail.com)
+
+All the initial work credits go to him! Thank you :)
+
+This version uses structs instead of ctypes.
+
+
+DDS Format
+----------
+
+::
+
+    [DDS ][SurfaceDesc][Data]
+
+    [SurfaceDesc]:: (everything is uint32)
+        Size
+        Flags
+        Height
+        Width
+        PitchOrLinearSize
+        Depth
+        MipmapCount
+        Reserved1 * 11
+        [PixelFormat]::
+            Size
+            Flags
+            FourCC
+            RGBBitCount
+            RBitMask
+            GBitMask
+            BBitMask
+            ABitMask
+        [Caps]::
+            Caps1
+            Caps2
+            Reserved1 * 2
+        Reserverd2
+
+.. warning::
+
+    This is an external library and Kivy does not provide any support for it.
+    It might change in the future and we advise you don't rely on it in your
+    code.
+
+'''
+# flake8: noqa
+
+from struct import pack, unpack, calcsize
+
+# DDSURFACEDESC2 dwFlags
+DDSD_CAPS                  = 0x00000001
+DDSD_HEIGHT                = 0x00000002
+DDSD_WIDTH                 = 0x00000004
+DDSD_PITCH                 = 0x00000008
+DDSD_PIXELFORMAT           = 0x00001000
+DDSD_MIPMAPCOUNT           = 0x00020000
+DDSD_LINEARSIZE            = 0x00080000
+DDSD_DEPTH                 = 0x00800000
+
+# DDPIXELFORMAT dwFlags
+DDPF_ALPHAPIXELS           = 0x00000001
+DDPF_FOURCC                = 0x00000004
+DDPF_RGB                   = 0x00000040
+DDPF_LUMINANCE             = 0x00020000
+
+# DDSCAPS2 dwCaps1
+DDSCAPS_COMPLEX            = 0x00000008
+DDSCAPS_TEXTURE            = 0x00001000
+DDSCAPS_MIPMAP             = 0x00400000
+
+# DDSCAPS2 dwCaps2
+DDSCAPS2_CUBEMAP           = 0x00000200
+DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400
+DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800
+DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000
+DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000
+DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000
+DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000
+DDSCAPS2_VOLUME            = 0x00200000
+
+# Common FOURCC codes
+DDS_DXTN = 0x00545844
+DDS_DXT1 = 0x31545844
+DDS_DXT2 = 0x32545844
+DDS_DXT3 = 0x33545844
+DDS_DXT4 = 0x34545844
+DDS_DXT5 = 0x35545844
+
+def dxt_to_str(dxt):
+    if dxt == DDS_DXT1:
+        return 's3tc_dxt1'
+    elif dxt == DDS_DXT2:
+        return 's3tc_dxt2'
+    elif dxt == DDS_DXT3:
+        return 's3tc_dxt3'
+    elif dxt == DDS_DXT4:
+        return 's3tc_dxt4'
+    elif dxt == DDS_DXT5:
+        return 's3tc_dxt5'
+    elif dxt == 0:
+        return 'rgba'
+    elif dxt == 1:
+        return 'alpha'
+    elif dxt == 2:
+        return 'luminance'
+    elif dxt == 3:
+        return 'luminance_alpha'
+
+def str_to_dxt(dxt):
+    if dxt == 's3tc_dxt1':
+        return DDS_DXT1
+    if dxt == 's3tc_dxt2':
+        return DDS_DXT2
+    if dxt == 's3tc_dxt3':
+        return DDS_DXT3
+    if dxt == 's3tc_dxt4':
+        return DDS_DXT4
+    if dxt == 's3tc_dxt5':
+        return DDS_DXT5
+    if dxt == 'rgba':
+        return 0
+    if dxt == 'alpha':
+        return 1
+    if dxt == 'luminance':
+        return 2
+    if dxt == 'luminance_alpha':
+        return 3
+
+def align_value(val, b):
+    return val + (-val % b)
+
+def check_flags(val, fl):
+    return (val & fl) == fl
+
+def dxt_size(w, h, dxt):
+    w = max(1, w // 4)
+    h = max(1, h // 4)
+    if dxt == DDS_DXT1:
+        return w * h * 8
+    elif dxt in (DDS_DXT2, DDS_DXT3, DDS_DXT4, DDS_DXT5):
+        return w * h * 16
+    return -1
+
+class QueryDict(dict):
+    def __getattr__(self, attr):
+        try:
+            return self.__getitem__(attr)
+        except KeyError:
+            try:
+                return super(QueryDict, self).__getattr__(attr)
+            except AttributeError:
+                raise KeyError(attr)
+
+    def __setattr__(self, attr, value):
+        self.__setitem__(attr, value)
+
+class DDSException(Exception):
+    pass
+
+
+class DDSFile(object):
+    fields = (
+        ('size', 0), ('flags', 1), ('height', 2),
+        ('width', 3), ('pitchOrLinearSize', 4), ('depth', 5),
+        ('mipmapCount', 6), ('pf_size', 18), ('pf_flags', 19),
+        ('pf_fourcc', 20), ('pf_rgbBitCount', 21), ('pf_rBitMask', 22),
+        ('pf_gBitMask', 23), ('pf_bBitMask', 24), ('pf_aBitMask', 25),
+        ('caps1', 26), ('caps2', 27))
+
+    def __init__(self, filename=None):
+        super(DDSFile, self).__init__()
+        self._dxt = 0
+        self._fmt = None
+        self.meta = meta = QueryDict()
+        self.count = 0
+        self.images = []
+        self.images_size = []
+        for field, index in DDSFile.fields:
+            meta[field] = 0
+        if filename:
+            self.load(filename)
+
+    def load(self, filename):
+        self.filename = filename
+        with open(filename, 'rb') as fd:
+            data = fd.read()
+
+        if data[:4] != b'DDS ':
+            raise DDSException('Invalid magic header {}'.format(data[:4]))
+
+        # read header
+        fmt = 'I' * 31
+        fmt_size = calcsize(fmt)
+        pf_size = calcsize('I' * 8)
+        header, data = data[4:4+fmt_size], data[4+fmt_size:]
+        if len(header) != fmt_size:
+            raise DDSException('Truncated header in')
+
+        # depack
+        header = unpack(fmt, header)
+        meta = self.meta
+        for name, index in DDSFile.fields:
+            meta[name] = header[index]
+
+        # check header validity
+        if meta.size != fmt_size:
+            raise DDSException('Invalid header size (%d instead of %d)' %
+                    (meta.size, fmt_size))
+        if meta.pf_size != pf_size:
+            raise DDSException('Invalid pixelformat size (%d instead of %d)' %
+                    (meta.pf_size, pf_size))
+        if not check_flags(meta.flags,
+                DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT):
+            raise DDSException('Not enough flags')
+        if not check_flags(meta.caps1, DDSCAPS_TEXTURE):
+            raise DDSException('Not a DDS texture')
+
+        self.count = 1
+        if check_flags(meta.flags, DDSD_MIPMAPCOUNT):
+            if not check_flags(meta.caps1, DDSCAPS_COMPLEX | DDSCAPS_MIPMAP):
+                raise DDSException('Invalid mipmap without flags')
+            self.count = meta.mipmapCount
+
+        hasrgb = check_flags(meta.pf_flags, DDPF_RGB)
+        hasalpha = check_flags(meta.pf_flags, DDPF_ALPHAPIXELS)
+        hasluminance = check_flags(meta.pf_flags, DDPF_LUMINANCE)
+        bpp = None
+        dxt = block = pitch = 0
+        if hasrgb or hasalpha or hasluminance:
+            bpp = meta.pf_rgbBitCount
+
+        if hasrgb and hasluminance:
+            raise DDSException('File have RGB and Luminance')
+
+        if hasrgb:
+            dxt = 0
+        elif hasalpha and not hasluminance:
+            dxt = 1
+        elif hasluminance and not hasalpha:
+            dxt = 2
+        elif hasalpha and hasluminance:
+            dxt = 3
+        elif check_flags(meta.pf_flags, DDPF_FOURCC):
+            dxt = meta.pf_fourcc
+            if dxt not in (DDS_DXT1, DDS_DXT2, DDS_DXT3, DDS_DXT4, DDS_DXT5):
+                raise DDSException('Unsupported FOURCC')
+        else:
+            raise DDSException('Unsupported format specified')
+
+        if bpp:
+            block = align_value(bpp, 8) // 8
+            pitch = align_value(block * meta.width, 4)
+
+        if check_flags(meta.flags, DDSD_LINEARSIZE):
+            if dxt in (0, 1, 2, 3):
+                size = pitch * meta.height
+            else:
+                size = dxt_size(meta.width, meta.height, dxt)
+
+        w = meta.width
+        h = meta.height
+        images = self.images
+        images_size = self.images_size
+        for i in range(self.count):
+            if dxt in (0, 1, 2, 3):
+                size = align_value(block * w, 4) * h
+            else:
+                size = dxt_size(w, h, dxt)
+            image, data = data[:size], data[size:]
+            if len(image) < size:
+                raise DDSException('Truncated image for mipmap %d' % i)
+            images_size.append((w, h))
+            images.append(image)
+            if w == 1 and h == 1:
+                break
+            w = max(1, w // 2)
+            h = max(1, h // 2)
+
+        if len(images) == 0:
+            raise DDSException('No images available')
+        if len(images) < self.count:
+            raise DDSException('Not enough images')
+
+        self._dxt = dxt
+
+    def save(self, filename):
+        if len(self.images) == 0:
+            raise DDSException('No images to save')
+
+        fields = dict(DDSFile.fields)
+        fields_keys = list(fields.keys())
+        fields_index = list(fields.values())
+        mget = self.meta.get
+        header = []
+        for idx in range(31):
+            if idx in fields_index:
+                value = mget(fields_keys[fields_index.index(idx)], 0)
+            else:
+                value = 0
+            header.append(value)
+
+        with open(filename, 'wb') as fd:
+            fd.write('DDS ')
+            fd.write(pack('I' * 31, *header))
+            for image in self.images:
+                fd.write(image)
+
+    def add_image(self, level, bpp, fmt, width, height, data):
+        assert(bpp == 32)
+        assert(fmt in ('rgb', 'rgba', 'dxt1', 'dxt2', 'dxt3', 'dxt4', 'dxt5'))
+        assert(width > 0)
+        assert(height > 0)
+        assert(level >= 0)
+
+        meta = self.meta
+        images = self.images
+        if len(images) == 0:
+            assert(level == 0)
+
+            # first image, set defaults !
+            for k in meta.keys():
+                meta[k] = 0
+
+            self._fmt = fmt
+            meta.size = calcsize('I' * 31)
+            meta.pf_size = calcsize('I' * 8)
+            meta.pf_flags = 0
+            meta.flags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT
+            meta.width = width
+            meta.height = height
+            meta.caps1 = DDSCAPS_TEXTURE
+
+            meta.flags |= DDSD_LINEARSIZE
+            meta.pitchOrLinearSize = len(data)
+
+            meta.pf_rgbBitCount = 32
+            meta.pf_rBitMask = 0x00ff0000
+            meta.pf_gBitMask = 0x0000ff00
+            meta.pf_bBitMask = 0x000000ff
+            meta.pf_aBitMask = 0xff000000
+
+            if fmt in ('rgb', 'rgba'):
+                assert(True)
+                assert(bpp == 32)
+                meta.pf_flags |= DDPF_RGB
+                meta.pf_rgbBitCount = 32
+                meta.pf_rBitMask = 0x00ff0000
+                meta.pf_gBitMask = 0x0000ff00
+                meta.pf_bBitMask = 0x000000ff
+                meta.pf_aBitMask = 0x00000000
+                if fmt == 'rgba':
+                    meta.pf_flags |= DDPF_ALPHAPIXELS
+                    meta.pf_aBitMask = 0xff000000
+            else:
+                meta.pf_flags |= DDPF_FOURCC
+                if fmt == 'dxt1':
+                    meta.pf_fourcc = DDS_DXT1
+                elif fmt == 'dxt2':
+                    meta.pf_fourcc = DDS_DXT2
+                elif fmt == 'dxt3':
+                    meta.pf_fourcc = DDS_DXT3
+                elif fmt == 'dxt4':
+                    meta.pf_fourcc = DDS_DXT4
+                elif fmt == 'dxt5':
+                    meta.pf_fourcc = DDS_DXT5
+
+            images.append(data)
+        else:
+            assert(level == len(images))
+            assert(fmt == self._fmt)
+
+            images.append(data)
+
+            meta.flags |= DDSD_MIPMAPCOUNT
+            meta.caps1 |= DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
+            meta.mipmapCount = len(images)
+
+    def __repr__(self):
+        return '<DDSFile filename=%r size=%r dxt=%r len(images)=%r>' % (
+                self.filename, self.size, self.dxt, len(self.images))
+
+    def _get_size(self):
+        meta = self.meta
+        return meta.width, meta.height
+    def _set_size(self, size):
+        self.meta.update({'width': size[0], 'height': size[1]})
+    size = property(_get_size, _set_size)
+
+    def _get_dxt(self):
+        return dxt_to_str(self._dxt)
+    def _set_dxt(self, dxt):
+        self._dxt = str_to_dxt(dxt)
+    dxt = property(_get_dxt, _set_dxt)
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) == 1:
+        print('Usage: python ddsfile.py <file1> <file2> ...')
+        sys.exit(0)
+    for filename in sys.argv[1:]:
+        print('=== Loading', filename)
+        try:
+            dds = DDSFile(filename=filename)
+            print(dds)
+            dds.save('bleh.dds')
+        except IOError as e:
+            print('ERR>', e)
+        except DDSException as e:
+            print('DDS>', e)
diff --git a/kivy/lib/gstplayer/__init__.py b/kivy/lib/gstplayer/__init__.py
new file mode 100644
index 0000000..1cd227e
--- /dev/null
+++ b/kivy/lib/gstplayer/__init__.py
@@ -0,0 +1,27 @@
+'''
+GstPlayer
+=========
+
+.. versionadded:: 1.8.0
+
+`GstPlayer` is a media player implemented specifically for Kivy with Gstreamer
+1.0. It doesn't use Gi at all and is focused on what we want: the ability
+to read video and stream the image in a callback, or read an audio file.
+Don't use it directly but use our Core providers instead.
+
+This player is automatically compiled if you have `pkg-config --libs --cflags
+gstreamer-1.0` working.
+
+.. warning::
+
+    This is an external library and Kivy does not provide any support for it.
+    It might change in the future and we advise you don't rely on it in your
+    code.
+'''
+
+import os
+if 'KIVY_DOC' in os.environ:
+    GstPlayer = get_gst_version = glib_iteration = None
+else:
+    from kivy.lib.gstplayer._gstplayer import (
+        GstPlayer, get_gst_version, glib_iteration)
diff --git a/kivy/lib/gstplayer/__pycache__/__init__.cpython-310.pyc b/kivy/lib/gstplayer/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..0ee36f7
Binary files /dev/null and b/kivy/lib/gstplayer/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/lib/mtdev.py b/kivy/lib/mtdev.py
new file mode 100644
index 0000000..98b2755
--- /dev/null
+++ b/kivy/lib/mtdev.py
@@ -0,0 +1,254 @@
+'''
+Python mtdev
+============
+
+The mtdev module provides Python bindings to the `Kernel multi-touch
+transformation library <https://launchpad.net/mtdev>`_, also known as mtdev
+(MIT license).
+
+The mtdev library transforms all variants of kernel MT events to the
+slotted type B protocol. The events put into mtdev may be from any MT
+device, specifically type A without contact tracking, type A with
+contact tracking, or type B with contact tracking. See the kernel
+documentation for further details.
+
+.. warning::
+
+    This is an external library and Kivy does not provide any support for it.
+    It might change in the future and we advise you don't rely on it in your
+    code.
+'''
+# flake8: noqa
+
+import os
+import time
+from ctypes import cdll, Structure, c_ulong, c_int, c_ushort, \
+                   c_void_p, pointer, POINTER, byref
+
+# load library
+if 'KIVY_DOC' not in os.environ:
+    libmtdev = cdll.LoadLibrary('libmtdev.so.1')
+
+# from linux/input.h
+MTDEV_CODE_SLOT          = 0x2f  # MT slot being modified
+MTDEV_CODE_TOUCH_MAJOR   = 0x30    # Major axis of touching ellipse
+MTDEV_CODE_TOUCH_MINOR   = 0x31    # Minor axis (omit if circular)
+MTDEV_CODE_WIDTH_MAJOR   = 0x32    # Major axis of approaching ellipse
+MTDEV_CODE_WIDTH_MINOR   = 0x33    # Minor axis (omit if circular)
+MTDEV_CODE_ORIENTATION   = 0x34    # Ellipse orientation
+MTDEV_CODE_POSITION_X    = 0x35    # Center X ellipse position
+MTDEV_CODE_POSITION_Y    = 0x36    # Center Y ellipse position
+MTDEV_CODE_TOOL_TYPE     = 0x37    # Type of touching device
+MTDEV_CODE_BLOB_ID       = 0x38    # Group a set of packets as a blob
+MTDEV_CODE_TRACKING_ID   = 0x39    # Unique ID of initiated contact
+MTDEV_CODE_PRESSURE      = 0x3a    # Pressure on contact area
+MTDEV_CODE_ABS_X		 = 0x00
+MTDEV_CODE_ABS_Y		 = 0x01
+MTDEV_CODE_ABS_Z		 = 0x02
+MTDEV_CODE_BTN_DIGI		        = 0x140
+MTDEV_CODE_BTN_TOOL_PEN		    = 0x140
+MTDEV_CODE_BTN_TOOL_RUBBER		= 0x141
+MTDEV_CODE_BTN_TOOL_BRUSH		= 0x142
+MTDEV_CODE_BTN_TOOL_PENCIL		= 0x143
+MTDEV_CODE_BTN_TOOL_AIRBRUSH	= 0x144
+MTDEV_CODE_BTN_TOOL_FINGER		= 0x145
+MTDEV_CODE_BTN_TOOL_MOUSE		= 0x146
+MTDEV_CODE_BTN_TOOL_LENS		= 0x147
+MTDEV_CODE_BTN_TOUCH		    = 0x14a
+MTDEV_CODE_BTN_STYLUS		    = 0x14b
+MTDEV_CODE_BTN_STYLUS2		    = 0x14c
+MTDEV_CODE_BTN_TOOL_DOUBLETAP	= 0x14d
+MTDEV_CODE_BTN_TOOL_TRIPLETAP	= 0x14e
+MTDEV_CODE_BTN_TOOL_QUADTAP	    = 0x14f	# Four fingers on trackpad
+
+MTDEV_TYPE_EV_ABS        = 0x03
+MTDEV_TYPE_EV_SYN        = 0x00
+MTDEV_TYPE_EV_KEY        = 0x01
+MTDEV_TYPE_EV_REL        = 0x02
+MTDEV_TYPE_EV_ABS        = 0x03
+MTDEV_TYPE_EV_MSC        = 0x04
+MTDEV_TYPE_EV_SW         = 0x05
+MTDEV_TYPE_EV_LED        = 0x11
+MTDEV_TYPE_EV_SND        = 0x12
+MTDEV_TYPE_EV_REP        = 0x14
+MTDEV_TYPE_EV_FF         = 0x15
+MTDEV_TYPE_EV_PWR        = 0x16
+MTDEV_TYPE_EV_FF_STATUS  = 0x17
+
+MTDEV_ABS_TRACKING_ID	= 9
+MTDEV_ABS_POSITION_X	= 5
+MTDEV_ABS_POSITION_Y	= 6
+MTDEV_ABS_TOUCH_MAJOR	= 0
+MTDEV_ABS_TOUCH_MINOR	= 1
+MTDEV_ABS_WIDTH_MAJOR	= 2
+MTDEV_ABS_WIDTH_MINOR	= 3
+MTDEV_ABS_ORIENTATION	= 4
+MTDEV_ABS_SIZE          = 11
+
+class timeval(Structure):
+    _fields_ = [
+        ('tv_sec', c_ulong),
+        ('tv_usec', c_ulong)
+    ]
+
+class input_event(Structure):
+    _fields_ = [
+        ('time', timeval),
+        ('type', c_ushort),
+        ('code', c_ushort),
+        ('value', c_int)
+    ]
+
+class input_absinfo(Structure):
+    _fields_ = [
+        ('value', c_int),
+        ('minimum', c_int),
+        ('maximum', c_int),
+        ('fuzz', c_int),
+        ('flat', c_int),
+        ('resolution', c_int)
+    ]
+
+class mtdev_caps(Structure):
+    _fields_ = [
+        ('has_mtdata', c_int),
+        ('has_slot', c_int),
+        ('has_abs', c_int * MTDEV_ABS_SIZE),
+        ('slot', input_absinfo),
+        ('abs', input_absinfo * MTDEV_ABS_SIZE)
+    ]
+
+class mtdev(Structure):
+    _fields_ = [
+        ('caps', mtdev_caps),
+        ('state', c_void_p)
+    ]
+
+# binding
+if 'KIVY_DOC' not in os.environ:
+    mtdev_open = libmtdev.mtdev_open
+    mtdev_open.argtypes = [POINTER(mtdev), c_int]
+    mtdev_get = libmtdev.mtdev_get
+    mtdev_get.argtypes = [POINTER(mtdev), c_int, POINTER(input_event), c_int]
+    mtdev_idle = libmtdev.mtdev_idle
+    mtdev_idle.argtypes = [POINTER(mtdev), c_int, c_int]
+    mtdev_close = libmtdev.mtdev_close
+    mtdev_close.argtypes = [POINTER(mtdev)]
+
+
+class Device:
+    def __init__(self, filename):
+        self._filename = filename
+        self._fd = -1
+        self._device = mtdev()
+
+        # Linux kernel creates input devices then hands permission changes
+        # off to udev. This results in a period of time when the device is
+        # readable only by root. Device reconnects can be processed by
+        # MTDMotionEventProvider faster than udev can get a chance to run,
+        # so we spin for a period of time to allow udev to fix permissions.
+        # We limit the loop time in case the system is misconfigured and
+        # the user really does not (and will not) have permission to access
+        # the device.
+        # Note: udev takes about 0.6 s on a Raspberry Pi 4
+        permission_wait_until = time.time() + 3.0
+        while self._fd == -1:
+            try:
+                self._fd = os.open(filename, os.O_NONBLOCK | os.O_RDONLY)
+            except PermissionError:
+                if time.time() > permission_wait_until:
+                    raise
+        ret = mtdev_open(pointer(self._device), self._fd)
+        if ret != 0:
+            os.close(self._fd)
+            self._fd = -1
+            raise Exception('Unable to open device')
+
+    def close(self):
+        '''Close the mtdev converter
+        '''
+        if self._fd == -1:
+            return
+        mtdev_close(pointer(self._device))
+        os.close(self._fd)
+        self._fd = -1
+
+    def idle(self, ms):
+        '''Check state of kernel device
+
+        :Parameters:
+            `ms`: int
+                Number of milliseconds to wait for activity
+
+        :Return:
+            Return True if the device is idle, i.e, there are no fetched events
+            in the pipe and there is nothing to fetch from the device.
+        '''
+        if self._fd == -1:
+            raise Exception('Device closed')
+        return bool(mtdev_idle(pointer(self._device), self._fd, ms))
+
+
+    def get(self):
+        if self._fd == -1:
+            raise Exception('Device closed')
+        ev = input_event()
+        if mtdev_get(pointer(self._device), self._fd, byref(ev), 1) <= 0:
+            return None
+        return ev
+
+    def has_mtdata(self):
+        '''Return True if the device has multitouch data.
+        '''
+        if self._fd == -1:
+            raise Exception('Device closed')
+        return bool(self._device.caps.has_mtdata)
+
+    def has_slot(self):
+        '''Return True if the device has slot information.
+        '''
+        if self._fd == -1:
+            raise Exception('Device closed')
+        return bool(self._device.caps.has_slot)
+
+    def has_abs(self, index):
+        '''Return True if the device has abs data.
+
+        :Parameters:
+            `index`: int
+                One of const starting with a name ABS_MT_
+        '''
+        if self._fd == -1:
+            raise Exception('Device closed')
+        if index < 0 or index >= MTDEV_ABS_SIZE:
+            raise IndexError('Invalid index')
+        return bool(self._device.caps.has_abs[index])
+
+    def get_max_abs(self):
+        '''Return the maximum number of abs information available.
+        '''
+        return MTDEV_ABS_SIZE
+
+    def get_slot(self):
+        '''Return the slot data.
+        '''
+        if self._fd == -1:
+            raise Exception('Device closed')
+        if self._device.caps.has_slot == 0:
+            return
+        return self._device.caps.slot
+
+    def get_abs(self, index):
+        '''Return the abs data.
+
+        :Parameters:
+            `index`: int
+                One of const starting with a name ABS_MT_
+        '''
+        if self._fd == -1:
+            raise Exception('Device closed')
+        if index < 0 or index >= MTDEV_ABS_SIZE:
+            raise IndexError('Invalid index')
+        return self._device.caps.abs[index]
+
+
diff --git a/kivy/lib/pango/pangoft2.pxi b/kivy/lib/pango/pangoft2.pxi
new file mode 100644
index 0000000..adf8f95
--- /dev/null
+++ b/kivy/lib/pango/pangoft2.pxi
@@ -0,0 +1,366 @@
+cdef extern from "glib.h" nogil:
+    ctypedef void *gpointer
+    ctypedef char gchar
+    ctypedef int gint
+    ctypedef unsigned int guint
+    ctypedef unsigned long gsize
+    ctypedef gint gboolean
+    gboolean TRUE
+    gboolean FALSE
+
+    void *g_malloc(gsize n_bytes)
+    void *g_malloc0(gsize n_bytes)
+    void g_free(gpointer mem)
+    void g_object_unref(gpointer obj)
+#    gpointer GUINT_TO_POINTER(guint u)
+#    guint GPOINTER_TO_UINT(gpointer p)
+
+# https://www.freetype.org/freetype2/docs/reference/ft2-index.html
+cdef extern from "../../lib/pango/freetype2.h" nogil:
+    int FREETYPE_MAJOR
+    int FREETYPE_MINOR
+    int FREETYPE_PATCH
+    ctypedef void *FT_Library
+    ctypedef void *FT_Face
+    ctypedef int FT_Error
+    ctypedef unsigned char *FT_Byte
+    ctypedef unsigned int FT_UInt
+    ctypedef unsigned short FT_UShort
+
+    ctypedef enum FT_Pixel_Mode:
+        FT_PIXEL_MODE_NONE = 0
+        FT_PIXEL_MODE_MONO
+        FT_PIXEL_MODE_GRAY
+        FT_PIXEL_MODE_GRAY2
+        FT_PIXEL_MODE_GRAY4
+        FT_PIXEL_MODE_LCD
+        FT_PIXEL_MODE_LCD_V
+        FT_PIXEL_MODE_BGRA
+        FT_PIXEL_MODE_MAX
+
+    ctypedef struct FT_Bitmap:
+        unsigned int rows
+        unsigned int width
+        int pitch
+        unsigned char* buffer
+        unsigned short num_grays
+        unsigned char pixel_mode
+        unsigned char palette_mode
+        void* palette
+
+    void FT_Bitmap_New(FT_Bitmap *bitmap) # <= v2.5
+    void FT_Bitmap_Init(FT_Bitmap *bitmap) # >= v2.6
+    void FT_Bitmap_Done(FT_Library library, FT_Bitmap *bitmap)
+
+    # For font face detection
+    FT_Error FT_Init_FreeType(FT_Library *library)
+    FT_Error FT_New_Face(FT_Library library, const char *pathname, long face_index, FT_Face *aface)
+    FT_Error FT_Done_Face(FT_Face face)
+    const char *FT_Get_Postscript_Name(FT_Face face)
+#    FT_Error FT_Get_Sfnt_Name(FT_Face face, FT_UInt idx, FT_SfntName *aname)
+#    FT_Error FT_Get_Sfnt_Name_Count(FT_Face face)
+
+
+# https://www.freedesktop.org/software/fontconfig/fontconfig-devel/t1.html
+cdef extern from "fontconfig/fontconfig.h" nogil:
+    ctypedef struct FcConfig:
+        pass
+    ctypedef struct FcPattern:
+        pass
+    ctypedef struct FcValue:
+        pass
+    ctypedef enum FcResult:
+        FcResultMatch
+        FcResultNoMatch
+        FcResultTypeMismatch
+        FcResultNoId
+
+    ctypedef bint FcBool
+    ctypedef unsigned char FcChar8
+    bint FcTrue
+    bint FcFalse
+    const char *FC_FAMILY
+    const char *FC_ANTIALIAS
+    const char *FC_HINTING
+    const char *FC_HINT_STYLE
+    int FC_HINT_NONE
+    int FC_HINT_SLIGHT
+    int FC_HINT_MEDIUM
+    int FC_HINT_FULL
+
+    FcConfig *FcConfigCreate()
+    FcConfig *FcInitLoadConfig()
+    FcConfig *FcInitLoadConfigAndFonts()
+    void FcConfigDestroy(FcConfig *config)
+    FcConfig *FcConfigGetCurrent()
+    FcBool FcConfigSetCurrent(FcConfig *config)
+    FcBool FcConfigAppFontAddFile(FcConfig *config, const FcChar8 *file)
+    FcBool FcConfigAppFontAddDir(FcConfig *config, const FcChar8 *dir)
+    void FcConfigAppFontClear(FcConfig *config)
+    FcBool FcConfigParseAndLoad(FcConfig *config, const FcChar8 *file, FcBool complain)
+    FcBool FcConfigSetRescanInterval(FcConfig *config, int rescaninterval)
+    int FcConfigGetRescanInterval(FcConfig *config)
+
+    FcResult FcPatternGetString(FcPattern *p, const char *object, int id, FcChar8 **s)
+    void FcPatternDestroy(FcPattern *p)
+    FcBool FcPatternDel(FcPattern *p, const char *object)
+    FcBool FcPatternAddInteger (FcPattern *p, const char *object, int i)
+    FcBool FcPatternAddBool (FcPattern *p, const char *object, FcBool b)
+#    FcPattern *FcPatternCreate()
+#    FcBool FcPatternAddDouble (FcPattern *p, const char *object, double d)
+#    FcBool FcPatternAddString (FcPattern *p, const char *object, const FcChar8 *s)
+#    FcBool FcPatternAddMatrix (FcPattern *p, const char *object, const FcMatrix *m)
+#    FcBool FcPatternAddCharSet (FcPattern *p, const char *object, const FcCharSet *c)
+#    FcBool FcPatternAddFTFace (FcPattern *p, const char *object, const FT_Facef)
+#    FcBool FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *l)
+#    FcBool FcPatternAddRange (FcPattern *p, const char *object, const FcRange *r)
+
+
+# https://www.freedesktop.org/software/fontconfig/fontconfig-devel/fcfreetypequeryface.html
+cdef extern from "fontconfig/fcfreetype.h" nogil:
+    FcPattern *FcFreeTypeQueryFace(const FT_Face face, const FcChar8 *file, unsigned int id, void *)
+
+
+# https://developer.gnome.org/pango/stable/pango-Version-Checking.html
+cdef extern from "pango/pango-utils.h":
+    int PANGO_VERSION_CHECK(int major, int minor, int micro)
+
+
+# https://developer.gnome.org/pango/stable/pango-Glyph-Storage.html
+cdef extern from "pango/pango-types.h" nogil:
+    unsigned int PANGO_SCALE
+
+
+# https://developer.gnome.org/pango/stable/pango-Text-Attributes.html
+cdef extern from "pango/pango-attributes.h" nogil:
+    guint PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING
+    guint PANGO_ATTR_INDEX_TO_TEXT_END
+
+    ctypedef struct PangoAttrList:
+        pass
+    ctypedef struct PangoAttrIterator:
+        pass
+    ctypedef struct PangoAttribute:
+        pass
+    ctypedef struct PangoAttrClass:
+        pass
+    ctypedef struct PangoAttrString:
+        pass
+    ctypedef struct PangoAttrLanguage:
+        pass
+    ctypedef struct PangoAttrInt:
+        pass
+    ctypedef struct PangoAttrSize:
+        pass
+    ctypedef struct PangoAttrFloat:
+        pass
+    ctypedef struct PangoAttrColor:
+        pass
+    ctypedef struct PangoAttrFontDesc:
+        pass
+    ctypedef struct PangoAttrShape:
+        pass
+    ctypedef struct PangoAttrFontFeatures:
+        pass
+    ctypedef enum PangoStyle:
+        PANGO_STYLE_NORMAL
+        PANGO_STYLE_OBLIQUE
+        PANGO_STYLE_ITALIC
+    # FIXME: investigate need to handle this for different pango versions
+    ctypedef enum PangoWeight:
+        PANGO_WEIGHT_THIN
+        PANGO_WEIGHT_ULTRALIGHT
+        PANGO_WEIGHT_LIGHT
+        PANGO_WEIGHT_SEMILIGHT
+        PANGO_WEIGHT_BOOK
+        PANGO_WEIGHT_NORMAL
+        PANGO_WEIGHT_MEDIUM
+        PANGO_WEIGHT_SEMIBOLD
+        PANGO_WEIGHT_BOLD
+        PANGO_WEIGHT_ULTRABOLD
+        PANGO_WEIGHT_HEAVY
+        PANGO_WEIGHT_ULTRAHEAVY
+    ctypedef enum PangoUnderline:
+        PANGO_UNDERLINE_NONE
+        PANGO_UNDERLINE_SINGLE
+        PANGO_UNDERLINE_DOUBLE
+        PANGO_UNDERLINE_LOW
+        PANGO_UNDERLINE_ERROR
+
+    PangoAttrList *pango_attr_list_new()
+    PangoAttrList *pango_attr_list_ref(PangoAttrList *list)
+    void pango_attr_list_unref(PangoAttrList *list)
+    void pango_attr_list_insert(PangoAttrList  *list, PangoAttribute *attr)
+    void pango_attr_list_insert_before(PangoAttrList  *list, PangoAttribute *attr)
+
+    PangoAttribute *pango_attr_language_new(PangoLanguage *language)
+    PangoAttribute *pango_attr_family_new(const char *family)
+    PangoAttribute *pango_attr_size_new(int size)
+    PangoAttribute *pango_attr_size_new_absolute(int size) # v1.8+
+    PangoAttribute *pango_attr_style_new(PangoStyle style)
+    PangoAttribute *pango_attr_weight_new(PangoWeight weight)
+#    PangoAttribute *pango_attr_variant_new(PangoVariant variant)
+#    PangoAttribute *pango_attr_stretch_new(PangoStretch stretch)
+    PangoAttribute *pango_attr_font_desc_new(const PangoFontDescription *desc)
+    PangoAttribute *pango_attr_underline_new(PangoUnderline underline)
+    PangoAttribute *pango_attr_strikethrough_new(gboolean strikethrough)
+    PangoAttribute *pango_attr_font_features_new(const gchar *features) # v1.38+
+
+
+# https://developer.gnome.org/pango/stable/pango-Scripts-and-Languages.html
+cdef extern from "pango/pango-language.h" nogil:
+    ctypedef struct PangoLanguage:
+        pass
+
+    PangoLanguage *pango_language_get_default()
+    PangoLanguage *pango_language_from_string(const char *language)
+    const char *pango_language_to_string(PangoLanguage *language)
+
+
+# https://developer.gnome.org/pango/stable/pango-FreeType-Fonts-and-Rendering.html
+cdef extern from "pango/pangoft2.h" nogil:
+    ctypedef struct PangoFT2FontMap:
+        pass
+    ctypedef void *PangoFT2SubstituteFunc
+    ctypedef void *GDestroyNotify
+
+    PangoFT2FontMap *PANGO_FT2_FONT_MAP(PangoFontMap *fontmap)
+    void pango_ft2_render_layout(FT_Bitmap *bitmap, PangoLayout *layout, int x, int y)
+    void pango_ft2_render_layout_subpixel(FT_Bitmap *bitmap, PangoLayout *layout, int x, int y)
+    void pango_ft2_font_map_set_default_substitute(PangoFT2FontMap *fontmap, PangoFT2SubstituteFunc func, gpointer data, GDestroyNotify notify)
+    void pango_ft2_font_map_substitute_changed(PangoFT2FontMap *fontmap)
+
+
+# https://developer.gnome.org/pango/stable/pango-Text-Processing.html
+cdef extern from "pango/pango-context.h" nogil:
+    ctypedef struct PangoContext:
+        pass
+
+    void pango_context_set_base_dir(PangoContext *context, PangoDirection direction)
+    void pango_context_set_font_description(PangoContext *context, const PangoFontDescription *desc)
+    PangoDirection pango_context_get_base_dir(PangoContext *context)
+    PangoFontMetrics *pango_context_get_metrics(PangoContext *context, const PangoFontDescription *desc, PangoLanguage *language)
+
+
+# https://developer.gnome.org/pango/stable/pango-Bidirectional-Text.html
+cdef extern from "pango/pango-bidi-type.h" nogil:
+    ctypedef enum PangoDirection:
+        PANGO_DIRECTION_LTR
+        PANGO_DIRECTION_RTL
+        PANGO_DIRECTION_TTB_LTR # deprecated
+        PANGO_DIRECTION_TTB_RTL # deprecated
+        PANGO_DIRECTION_WEAK_LTR
+        PANGO_DIRECTION_WEAK_RTL
+        PANGO_DIRECTION_NEUTRAL
+    PangoDirection pango_find_base_dir(const gchar *text, gint length)
+
+
+# https://developer.gnome.org/pango/stable/pango-Fonts.html
+cdef extern from "pango/pango-font.h" nogil:
+    ctypedef struct PangoFontMap:
+        pass
+    ctypedef struct PangoFontDescription:
+        pass
+    ctypedef struct PangoFontMetrics:
+        pass
+    ctypedef struct PangoFontFamily:
+        pass
+
+    PangoFontMap *pango_ft2_font_map_new()
+    PangoFontDescription* pango_font_description_new()
+    PangoFontDescription* pango_font_description_from_string(const char *string)
+    void pango_font_description_free(PangoFontDescription *desc)
+    int pango_font_metrics_get_ascent(PangoFontMetrics *metrics)
+    int pango_font_metrics_get_descent(PangoFontMetrics *metrics)
+    void pango_font_metrics_unref(PangoFontMetrics *metrics)
+    const char *pango_font_family_get_name(PangoFontFamily *family)
+
+    # Font descriptions:
+    void pango_font_description_set_family(PangoFontDescription *desc, const char *family)
+    const char *pango_font_description_get_family(PangoFontDescription *desc)
+
+    void pango_font_description_set_size(PangoFontDescription *desc, gint size)
+    void pango_font_description_set_absolute_size(PangoFontDescription *desc, gint size) # v1.8+
+    gint pango_font_description_get_size(PangoFontDescription *desc)
+
+    void pango_font_description_set_weight(PangoFontDescription *desc, PangoWeight weight)
+    PangoWeight pango_font_description_get_weight(PangoFontDescription *desc)
+
+    void pango_font_description_set_style(PangoFontDescription *desc, PangoStyle style)
+    PangoStyle pango_font_description_get_style(PangoFontDescription *desc)
+
+
+# https://developer.gnome.org/pango/stable/pango-Fonts.html
+cdef extern from "pango/pango-fontmap.h" nogil:
+    void pango_font_map_list_families(PangoFontMap *fontmap, PangoFontFamily ***families, int *n_families)
+
+
+# https://developer.gnome.org/pango/stable/PangoFcFontMap.html
+cdef extern from "pango/pangofc-fontmap.h" nogil:
+    ctypedef struct PangoFcFontMap:
+        pass
+
+    PangoFcFontMap *PANGO_FC_FONT_MAP(PangoFontMap *fontmap)
+    void pango_fc_font_map_set_config(PangoFcFontMap *fontmap, FcConfig *config)
+    void pango_fc_font_map_config_changed(PangoFcFontMap *fontmap)
+
+
+# https://developer.gnome.org/pango/stable/pango-Layout-Objects.html
+cdef extern from "pango/pango-layout.h" nogil:
+    ctypedef struct PangoLayout:
+        pass
+
+    ctypedef enum PangoAlignment:
+        PANGO_ALIGN_LEFT
+        PANGO_ALIGN_CENTER
+        PANGO_ALIGN_RIGHT
+    ctypedef enum PangoWrapMode:
+        PANGO_WRAP_WORD
+        PANGO_WRAP_CHAR
+        PANGO_WRAP_WORD_CHAR
+    ctypedef enum PangoEllipsizeMode:
+        PANGO_ELLIPSIZE_NONE
+        PANGO_ELLIPSIZE_START
+        PANGO_ELLIPSIZE_MIDDLE
+        PANGO_ELLIPSIZE_END
+
+    PangoLayout *pango_layout_new(PangoContext *context)
+    void pango_layout_context_changed(PangoLayout *layout)
+    void pango_layout_set_attributes(PangoLayout *layout, PangoAttrList *attrs)
+    void pango_layout_set_text(PangoLayout *layout, const char *text, int length)
+    void pango_layout_set_markup(PangoLayout *layout, const char *markup, int length)
+    void pango_layout_set_font_description(PangoLayout *layout, const PangoFontDescription *desc)
+    void pango_layout_get_pixel_size(PangoLayout *layout, int *width, int *height)
+    void pango_layout_get_size(PangoLayout *layout, int *width, int *height)
+    int pango_layout_get_baseline(PangoLayout *layout)
+    int pango_layout_get_line_count(PangoLayout *layout)
+    int pango_layout_get_unknown_glyphs_count(PangoLayout *layout)
+    gboolean pango_layout_xy_to_index(PangoLayout *layout, int x, int y, int *index, int *trailing)
+
+    void pango_layout_set_ellipsize(PangoLayout *layout, PangoEllipsizeMode ellipsize)
+    PangoEllipsizeMode pango_layout_get_ellipsize(PangoLayout *layout)
+    gboolean pango_layout_is_ellipsized(PangoLayout *layout)
+
+    void pango_layout_set_wrap(PangoLayout *layout, PangoWrapMode wrap)
+    PangoWrapMode pango_layout_get_wrap(PangoLayout *layout)
+    gboolean pango_layout_is_wrapped(PangoLayout *layout)
+
+    void pango_layout_set_alignment(PangoLayout *layout, PangoAlignment alignment)
+    PangoAlignment pango_layout_get_alignment(PangoLayout *layout)
+    void pango_layout_set_auto_dir(PangoLayout *layout, gboolean auto_dir)
+    gboolean pango_layout_get_auto_dir(PangoLayout *layout)
+    void pango_layout_set_width(PangoLayout *layout, int width)
+    int pango_layout_get_width(PangoLayout *layout)
+    void pango_layout_set_height(PangoLayout *layout, int height)
+    int pango_layout_get_height(PangoLayout *layout)
+    void pango_layout_set_spacing(PangoLayout *layout, int spacing)
+    int pango_layout_get_spacing(PangoLayout *layout)
+    void pango_layout_set_indent(PangoLayout *layout, int indent)
+    int pango_layout_get_indent(PangoLayout *layout)
+    void pango_layout_set_justify(PangoLayout *layout, gboolean justify)
+    gboolean pango_layout_get_justify(PangoLayout *layout)
+    void pango_layout_set_single_paragraph_mode(PangoLayout *layout, gboolean setting)
+    gboolean pango_layout_get_single_paragraph_mode(PangoLayout *layout)
+
+cdef extern from "../../lib/pango/pangoft2.h" nogil:
+    PangoContext *_pango_font_map_create_context(PangoFontMap *fontmap)
diff --git a/kivy/lib/sdl2.pxi b/kivy/lib/sdl2.pxi
new file mode 100644
index 0000000..6a539de
--- /dev/null
+++ b/kivy/lib/sdl2.pxi
@@ -0,0 +1,1076 @@
+#Copyright (c) 2010-2012, Gabriel Jacobo
+#All rights reserved.
+#Permission to use this file is granted under the conditions of the Ignifuga Game Engine License
+#whose terms are available in the LICENSE file or at http://www.ignifuga.org/license
+
+include "../include/config.pxi"
+
+cdef extern from "SDL_joystick.h":
+    cdef struct SDL_Joystick
+    cdef int SDL_HAT_CENTERED = 0x00
+    cdef int SDL_HAT_UP = 0x01
+    cdef int SDL_HAT_RIGHT = 0x02
+    cdef int SDL_HAT_DOWN = 0x04
+    cdef int SDL_HAT_LEFT = 0x08
+
+cdef extern from "SDL.h":
+    ctypedef unsigned char Uint8
+    ctypedef unsigned long Uint32
+    ctypedef signed long Sint32
+    ctypedef unsigned long long Uint64
+    ctypedef signed long long Sint64
+    ctypedef signed short Sint16
+    ctypedef unsigned short Uint16
+    ctypedef void *SDL_GLContext
+    ctypedef Uint32 SDL_Keycode
+    ctypedef Sint32 SDL_JoystickID
+
+    int SDL_WINDOWPOS_UNDEFINED
+
+    ctypedef enum:
+        SDL_PIXELFORMAT_BGRA8888
+        SDL_PIXELFORMAT_ARGB8888
+        SDL_PIXELFORMAT_RGBA8888
+        SDL_PIXELFORMAT_ABGR8888
+        SDL_PIXELFORMAT_RGB24
+        SDL_PIXELFORMAT_BGR24
+
+    ctypedef enum SDL_GLattr:
+        SDL_GL_RED_SIZE
+        SDL_GL_GREEN_SIZE
+        SDL_GL_BLUE_SIZE
+        SDL_GL_ALPHA_SIZE
+        SDL_GL_BUFFER_SIZE
+        SDL_GL_DOUBLEBUFFER
+        SDL_GL_DEPTH_SIZE
+        SDL_GL_STENCIL_SIZE
+        SDL_GL_ACCUM_RED_SIZE
+        SDL_GL_ACCUM_GREEN_SIZE
+        SDL_GL_ACCUM_BLUE_SIZE
+        SDL_GL_ACCUM_ALPHA_SIZE
+        SDL_GL_STEREO
+        SDL_GL_MULTISAMPLEBUFFERS
+        SDL_GL_MULTISAMPLESAMPLES
+        SDL_GL_ACCELERATED_VISUAL
+        SDL_GL_RETAINED_BACKING
+        SDL_GL_CONTEXT_MAJOR_VERSION
+        SDL_GL_CONTEXT_MINOR_VERSION
+        SDL_GL_CONTEXT_EGL
+        SDL_GL_CONTEXT_FLAGS
+        SDL_GL_CONTEXT_PROFILE_MASK
+
+    ctypedef enum SDL_SystemCursor:
+        SDL_SYSTEM_CURSOR_ARROW
+        SDL_SYSTEM_CURSOR_IBEAM
+        SDL_SYSTEM_CURSOR_WAIT
+        SDL_SYSTEM_CURSOR_CROSSHAIR
+        SDL_SYSTEM_CURSOR_WAITARROW
+        SDL_SYSTEM_CURSOR_SIZENWSE
+        SDL_SYSTEM_CURSOR_SIZENESW
+        SDL_SYSTEM_CURSOR_SIZEWE
+        SDL_SYSTEM_CURSOR_SIZENS
+        SDL_SYSTEM_CURSOR_SIZEALL
+        SDL_SYSTEM_CURSOR_NO
+        SDL_SYSTEM_CURSOR_HAND
+
+    ctypedef enum SDL_BlendMode:
+        SDL_BLENDMODE_NONE = 0x00000000
+        SDL_BLENDMODE_BLEND = 0x00000001
+        SDL_BLENDMODE_ADD = 0x00000002
+        SDL_BLENDMODE_MOD = 0x00000004
+
+    ctypedef enum SDL_TextureAccess:
+        SDL_TEXTUREACCESS_STATIC
+        SDL_TEXTUREACCESS_STREAMING
+        SDL_TEXTUREACCESS_TARGET
+
+    ctypedef enum SDL_RendererFlags:
+        SDL_RENDERER_SOFTWARE = 0x00000001
+        SDL_RENDERER_ACCELERATED = 0x00000002
+        SDL_RENDERER_PRESENTVSYNC = 0x00000004
+
+    ctypedef enum SDL_bool:
+        SDL_FALSE = 0
+        SDL_TRUE = 1
+
+    cdef struct SDL_version:
+        Uint8 major
+        Uint8 minor
+        Uint8 patch
+
+    cdef struct SDL_Rect:
+        int x, y
+        int w, h
+
+    ctypedef struct SDL_Point:
+        int x, y
+
+    cdef struct SDL_Color:
+        Uint8 r
+        Uint8 g
+        Uint8 b
+        Uint8 a
+
+    cdef struct SDL_Palette:
+        int ncolors
+        SDL_Color *colors
+        Uint32 version
+        int refcount
+
+    cdef struct SDL_PixelFormat:
+        Uint32 format
+        SDL_Palette *palette
+        Uint8 BitsPerPixel
+        Uint8 BytesPerPixel
+        Uint8 padding[2]
+        Uint32 Rmask
+        Uint32 Gmask
+        Uint32 Bmask
+        Uint32 Amask
+        Uint8 Rloss
+        Uint8 Gloss
+        Uint8 Bloss
+        Uint8 Aloss
+        Uint8 Rshift
+        Uint8 Gshift
+        Uint8 Bshift
+        Uint8 Ashift
+        int refcount
+        SDL_PixelFormat *next
+
+
+    cdef struct SDL_BlitMap
+
+    cdef struct SDL_Cursor
+
+    cdef struct SDL_Surface:
+        Uint32 flags
+        SDL_PixelFormat *format
+        int w, h
+        int pitch
+        void *pixels
+        void *userdata
+        int locked
+        void *lock_data
+        SDL_Rect clip_rect
+        SDL_BlitMap *map
+        int refcount
+
+
+    ctypedef enum SDL_EventType:
+        SDL_FIRSTEVENT     = 0,
+        SDL_DROPFILE       = 0x1000,
+        SDL_DROPTEXT
+        SDL_DROPBEGIN
+        SDL_DROPCOMPLETE
+        SDL_QUIT           = 0x100
+        SDL_WINDOWEVENT    = 0x200
+        SDL_SYSWMEVENT
+        SDL_KEYDOWN        = 0x300
+        SDL_KEYUP
+        SDL_TEXTEDITING
+        SDL_TEXTINPUT
+        SDL_MOUSEMOTION     = 0x400
+        SDL_MOUSEBUTTONDOWN = 0x401
+        SDL_MOUSEBUTTONUP   = 0x402
+        SDL_MOUSEWHEEL      = 0x403
+        SDL_INPUTMOTION     = 0x500
+        SDL_INPUTBUTTONDOWN
+        SDL_INPUTBUTTONUP
+        SDL_INPUTWHEEL
+        SDL_INPUTPROXIMITYIN
+        SDL_INPUTPROXIMITYOUT
+        SDL_JOYAXISMOTION  = 0x600
+        SDL_JOYBALLMOTION
+        SDL_JOYHATMOTION
+        SDL_JOYBUTTONDOWN
+        SDL_JOYBUTTONUP
+        SDL_FINGERDOWN      = 0x700
+        SDL_FINGERUP
+        SDL_FINGERMOTION
+        SDL_TOUCHBUTTONDOWN
+        SDL_TOUCHBUTTONUP
+        SDL_DOLLARGESTURE   = 0x800
+        SDL_DOLLARRECORD
+        SDL_MULTIGESTURE
+        SDL_CLIPBOARDUPDATE = 0x900
+        SDL_EVENT_COMPAT1 = 0x7000
+        SDL_EVENT_COMPAT2
+        SDL_EVENT_COMPAT3
+        SDL_USEREVENT    = 0x8000
+        SDL_LASTEVENT    = 0xFFFF
+        SDL_APP_TERMINATING
+        SDL_APP_LOWMEMORY
+        SDL_APP_WILLENTERBACKGROUND
+        SDL_APP_DIDENTERBACKGROUND
+        SDL_APP_WILLENTERFOREGROUND
+        SDL_APP_DIDENTERFOREGROUND
+
+    ctypedef enum SDL_WindowEventID:
+        SDL_WINDOWEVENT_NONE           #< Never used */
+        SDL_WINDOWEVENT_SHOWN          #< Window has been shown */
+        SDL_WINDOWEVENT_HIDDEN         #< Window has been hidden */
+        SDL_WINDOWEVENT_EXPOSED        #< Window has been exposed and should be
+                                        #     redrawn */
+        SDL_WINDOWEVENT_MOVED          #< Window has been moved to data1, data2
+                                        # */
+        SDL_WINDOWEVENT_RESIZED        #< Window has been resized to data1xdata2 */
+        SDL_WINDOWEVENT_SIZE_CHANGED   #< The window size has changed, either as a result of an API call or through the system or user changing the window size. */
+        SDL_WINDOWEVENT_MINIMIZED      #< Window has been minimized */
+        SDL_WINDOWEVENT_MAXIMIZED      #< Window has been maximized */
+        SDL_WINDOWEVENT_RESTORED       #< Window has been restored to normal size
+                                        # and position */
+        SDL_WINDOWEVENT_ENTER          #< Window has gained mouse focus */
+        SDL_WINDOWEVENT_LEAVE          #< Window has lost mouse focus */
+        SDL_WINDOWEVENT_FOCUS_GAINED   #< Window has gained keyboard focus */
+        SDL_WINDOWEVENT_FOCUS_LOST     #< Window has lost keyboard focus */
+        SDL_WINDOWEVENT_CLOSE          #< The window manager requests that the
+                                        # window be closed */
+
+    ctypedef enum SDL_HintPriority:
+        SDL_HINT_DEFAULT
+        SDL_HINT_NORMAL
+        SDL_HINT_OVERRIDE
+
+    ctypedef enum SDL_RendererFlip:
+        SDL_FLIP_NONE = 0x00000000
+        SDL_FLIP_HORIZONTAL = 0x00000001
+        SDL_FLIP_VERTICAL = 0x00000002
+
+    ctypedef enum SDL_WindowFlags:
+        SDL_WINDOW_FULLSCREEN = 0x00000001      #,         /**< fullscreen window */
+        SDL_WINDOW_OPENGL = 0x00000002          #,             /**< window usable with OpenGL context */
+        SDL_WINDOW_SHOWN = 0x00000004           #,              /**< window is visible */
+        SDL_WINDOW_HIDDEN = 0x00000008          #,             /**< window is not visible */
+        SDL_WINDOW_BORDERLESS = 0x00000010      #,         /**< no window decoration */
+        SDL_WINDOW_RESIZABLE = 0x00000020       #,          /**< window can be resized */
+        SDL_WINDOW_MINIMIZED = 0x00000040       #,          /**< window is minimized */
+        SDL_WINDOW_MAXIMIZED = 0x00000080       #,          /**< window is maximized */
+        SDL_WINDOW_INPUT_GRABBED = 0x00000100   #,      /**< window has grabbed input focus */
+        SDL_WINDOW_INPUT_FOCUS = 0x00000200     #,        /**< window has input focus */
+        SDL_WINDOW_MOUSE_FOCUS = 0x00000400     #,        /**< window has mouse focus */
+        SDL_WINDOW_FOREIGN = 0x00000800         #            /**< window not created by SDL */
+        SDL_WINDOW_FULLSCREEN_DESKTOP
+        SDL_WINDOW_ALLOW_HIGHDPI
+
+    ctypedef enum SDL_HitTestResult:
+        SDL_HITTEST_NORMAL
+        SDL_HITTEST_DRAGGABLE
+        SDL_HITTEST_RESIZE_TOPLEFT
+        SDL_HITTEST_RESIZE_TOP
+        SDL_HITTEST_RESIZE_TOPRIGHT
+        SDL_HITTEST_RESIZE_RIGHT
+        SDL_HITTEST_RESIZE_BOTTOMRIGHT
+        SDL_HITTEST_RESIZE_BOTTOM
+        SDL_HITTEST_RESIZE_BOTTOMLEFT
+        SDL_HITTEST_RESIZE_LEFT
+
+
+    cdef struct SDL_DropEvent:
+        Uint32 type
+        Uint32 timestamp
+        char* file
+
+    cdef struct SDL_MouseMotionEvent:
+        Uint32 type
+        Uint32 timestamp
+        Uint32 windowID
+        Uint32 which
+        Uint32 state
+        Sint32 x
+        Sint32 y
+        Sint32 xrel
+        Sint32 yrel
+
+    cdef struct SDL_MouseButtonEvent:
+        Uint32 type
+        Uint32 timestamp
+        Uint32 windowID
+        Uint32 which
+        Uint8 button
+        Uint8 state
+        Uint8 clicks
+        Sint32 x
+        Sint32 y
+
+    cdef struct SDL_WindowEvent:
+        Uint32 type
+        Uint32 timestamp
+        Uint32 windowID
+        Uint8 event
+        Sint32 data1
+        Sint32 data2
+
+    ctypedef Sint64 SDL_TouchID
+    ctypedef Sint64 SDL_FingerID
+
+    cdef struct SDL_TouchFingerEvent:
+        Uint32 type
+        Uint32 windowID
+        SDL_TouchID touchId
+        SDL_FingerID fingerId
+        float x
+        float y
+        float dx
+        float dy
+        float pressure
+
+    cdef struct SDL_Keysym:
+        SDL_Scancode scancode       # SDL physical key code - see ::SDL_Scancode for details */
+        SDL_Keycode sym             # SDL virtual key code - see ::SDL_Keycode for details */
+        Uint16 mod                  # current key modifiers */
+        Uint32 unused
+
+    cdef struct SDL_KeyboardEvent:
+        Uint32 type         # ::SDL_KEYDOWN or ::SDL_KEYUP
+        Uint32 timestamp
+        Uint32 windowID     # The window with keyboard focus, if any
+        Uint8 state         # ::SDL_PRESSED or ::SDL_RELEASED
+        Uint8 repeat        # Non-zero if this is a key repeat
+        SDL_Keysym keysym   # The key that was pressed or released
+
+    cdef struct SDL_TextEditingEvent:
+        Uint32 type                                 # ::SDL_TEXTEDITING */
+        Uint32 timestamp
+        Uint32 windowID                             # The window with keyboard focus, if any */
+        char *text                                  # The editing text */
+        Sint32 start                                # The start cursor of selected editing text */
+        Sint32 length                               # The length of selected editing text */
+
+    cdef struct SDL_TextInputEvent:
+        Uint32 type                               # ::SDL_TEXTINPUT */
+        Uint32 timestamp
+        Uint32 windowID                           # The window with keyboard focus, if any */
+        char *text                                # The input text */
+
+    cdef struct SDL_MouseWheelEvent:
+        Uint32 type
+        Uint32 windowID
+        int x
+        int y
+    cdef struct SDL_JoyAxisEvent:
+        Uint32 type
+        Uint32 timestamp
+        SDL_JoystickID which
+        Uint8 axis
+        Sint16 value
+    cdef struct SDL_JoyBallEvent:
+        Uint32 type
+        Uint32 timestamp
+        SDL_JoystickID which
+        Uint8 ball
+        Sint16  xrel
+        Sint16  yrel
+    cdef struct SDL_JoyHatEvent:
+        Uint32 type
+        Uint32 timestamp
+        SDL_JoystickID which
+        Uint8 hat
+        Uint8 value
+    cdef struct SDL_JoyButtonEvent:
+        Uint32 type
+        Uint32 timestamp
+        SDL_JoystickID which
+        Uint8 button
+        Uint8 state
+    cdef struct SDL_QuitEvent:
+        pass
+    cdef struct SDL_UserEvent:
+        Uint32 type
+        Uint32 timestamp
+        Uint32 windowID
+        int code
+        void *data1
+        void *data2
+
+    cdef struct SDL_SysWMEvent:
+        pass
+    cdef struct SDL_TouchButtonEvent:
+        pass
+    cdef struct SDL_MultiGestureEvent:
+        pass
+    cdef struct SDL_DollarGestureEvent:
+        pass
+
+    cdef union SDL_Event:
+        Uint32 type
+        SDL_WindowEvent window
+        SDL_KeyboardEvent key
+        SDL_TextEditingEvent edit
+        SDL_TextInputEvent text
+        SDL_MouseMotionEvent motion
+        SDL_MouseButtonEvent button
+        SDL_DropEvent drop
+        SDL_MouseWheelEvent wheel
+        SDL_JoyAxisEvent jaxis
+        SDL_JoyBallEvent jball
+        SDL_JoyHatEvent jhat
+        SDL_JoyButtonEvent jbutton
+        SDL_QuitEvent quit
+        SDL_UserEvent user
+        SDL_SysWMEvent syswm
+        SDL_TouchFingerEvent tfinger
+        SDL_TouchButtonEvent tbutton
+        SDL_MultiGestureEvent mgesture
+        SDL_DollarGestureEvent dgesture
+
+    cdef struct SDL_RendererInfo:
+        char *name
+        Uint32 flags
+        Uint32 num_texture_formats
+        Uint32 texture_formats[16]
+        int max_texture_width
+        int max_texture_height
+
+    ctypedef struct SDL_Texture
+    ctypedef struct SDL_Renderer
+    ctypedef struct SDL_Window
+    ctypedef struct SDL_DisplayMode:
+        Uint32 format
+        int w
+        int h
+        int refresh_rate
+        void *driverdata
+
+    cdef struct SDL_RWops_union_unknown:
+        void *data1
+
+    cdef union SDL_RWops_union:
+        SDL_RWops_union_unknown unknown
+
+    cdef struct SDL_RWops:
+        Sint64 (* seek) (SDL_RWops * context, Sint64 offset,int whence)
+        size_t(* read) ( SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+        size_t(* write) (SDL_RWops * context, void *ptr,size_t size, size_t num)
+        int (* close) (SDL_RWops * context)
+        int type
+        SDL_RWops_union hidden
+
+    cdef enum SDL_Keymod:
+        KMOD_NONE
+        KMOD_LSHIFT
+        KMOD_RSHIFT
+        KMOD_LCTRL
+        KMOD_RCTRL
+        KMOD_LALT
+        KMOD_RALT
+        KMOD_LGUI
+        KMOD_RGUI
+        KMOD_NUM
+        KMOD_CAPS
+        KMOD_MODE
+        KMOD_RESERVED
+
+    ctypedef enum SDL_Scancode:
+        pass
+
+    ctypedef int SDL_EventFilter(void* userdata, SDL_Event* event)
+    # for windows only see
+    # https://github.com/LuaDist/sdl/blob/master/include/begin_code.h#L68
+    IF UNAME_SYSNAME == 'Windows':
+        ctypedef SDL_HitTestResult (__cdecl *SDL_HitTest) (SDL_Window *win, const SDL_Point *area, void *data)
+    ELSE:
+        ctypedef SDL_HitTestResult (*SDL_HitTest)(SDL_Window *win, const SDL_Point *area, void *data)
+
+    cdef char *SDL_HINT_ORIENTATIONS
+    cdef char *SDL_HINT_VIDEO_WIN_D3DCOMPILER
+    cdef char *SDL_HINT_ACCELEROMETER_AS_JOYSTICK
+    cdef char *SDL_HINT_ANDROID_TRAP_BACK_BUTTON
+
+    cdef int SDL_QUERY               = -1
+    cdef int SDL_IGNORE              =  0
+    cdef int SDL_DISABLE             =  0
+    cdef int SDL_ENABLE              =  1
+    cdef int SDL_INIT_TIMER          = 0x00000001
+    cdef int SDL_INIT_AUDIO          = 0x00000010
+    cdef int SDL_INIT_VIDEO          = 0x00000020  # SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
+    cdef int SDL_INIT_JOYSTICK       = 0x00000200  # SDL_INIT_JOYSTICK implies SDL_INIT_EVENTS */
+    cdef int SDL_INIT_HAPTIC         = 0x00001000
+    cdef int SDL_INIT_GAMECONTROLLER = 0x00002000  # SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK */
+    cdef int SDL_INIT_EVENTS         = 0x00004000
+    cdef int SDL_INIT_NOPARACHUTE    = 0x00100000  # Don't catch fatal signals */
+
+    cdef void SDL_GetVersion(SDL_version * ver)
+    cdef SDL_Renderer * SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
+    cdef void SDL_DestroyRenderer (SDL_Renderer * renderer)
+    cdef SDL_Texture * SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int h)
+    cdef SDL_Texture * SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
+    cdef SDL_Surface * SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) nogil
+    cdef int SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Rect * srcrect, SDL_Rect * dstrect)
+    cdef int SDL_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture, SDL_Rect * srcrect, SDL_Rect * dstrect, double angle, SDL_Point *center, SDL_RendererFlip flip)
+    cdef void SDL_RenderPresent(SDL_Renderer * renderer)
+    cdef SDL_bool SDL_RenderTargetSupported(SDL_Renderer *renderer)
+    cdef int SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+    cdef void SDL_DestroyTexture(SDL_Texture * texture)
+    cdef void SDL_FreeSurface(SDL_Surface * surface) nogil
+    cdef int SDL_SetSurfaceBlendMode(SDL_Surface * surface, int blendMode)
+    cdef int SDL_SetSurfaceAlphaMod(SDL_Surface * surface, char alpha)
+    cdef int SDL_UpperBlit (SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect)
+    cdef int SDL_BlitSurface(SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect)
+    cdef int SDL_LockTexture(SDL_Texture * texture, SDL_Rect * rect, void **pixels, int *pitch)
+    cdef void SDL_UnlockTexture(SDL_Texture * texture)
+    cdef void SDL_GetWindowSize(SDL_Window * window, int *w, int *h)
+    cdef Uint32 SDL_GetWindowFlags(SDL_Window * window)
+    cdef SDL_Window * SDL_CreateWindow(char *title, int x, int y, int w, int h, Uint32 flags)
+    cdef void SDL_DestroyWindow (SDL_Window * window)
+    cdef int SDL_SetRenderDrawColor(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+    cdef int SDL_RenderClear(SDL_Renderer * renderer)
+    cdef int SDL_SetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode blendMode)
+    cdef int SDL_GetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode *blendMode)
+    cdef SDL_Surface * SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
+    cdef SDL_Surface* SDL_ConvertSurfaceFormat(SDL_Surface* src, Uint32 pixel_format, Uint32 flags) nogil
+    cdef const char* SDL_GetPixelFormatName(Uint32 format)
+    cdef int SDL_GetColorKey(SDL_Surface *surface, Uint32 *key)
+    cdef int SDL_Init(Uint32 flags)
+    cdef void SDL_Quit()
+    cdef int SDL_EnableUNICODE(int enable)
+    cdef Uint32 SDL_GetTicks()
+    cdef void SDL_Delay(Uint32 ms) nogil
+    cdef Uint8 SDL_EventState(Uint32 type, int state)
+    cdef int SDL_PollEvent(SDL_Event * event) nogil
+    cdef void SDL_SetEventFilter(SDL_EventFilter *filter, void* userdata)
+    cdef SDL_RWops * SDL_RWFromFile(char *file, char *mode)
+    cdef SDL_RWops * SDL_RWFromMem(void *mem, int size)
+    cdef SDL_RWops * SDL_RWFromConstMem(void *mem, int size)
+    cdef SDL_RWops * SDL_AllocRW()
+    cdef void SDL_FreeRW(SDL_RWops *area)
+    cdef int SDL_GetRendererInfo(SDL_Renderer *renderer, SDL_RendererInfo *info)
+    cdef int SDL_RenderSetViewport(SDL_Renderer * renderer, SDL_Rect * rect)
+    cdef int SDL_GetCurrentDisplayMode(int displayIndex, SDL_DisplayMode * mode)
+    cdef int SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode * mode)
+    cdef int SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)
+    cdef int SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)
+    cdef char * SDL_GetError()
+    cdef SDL_bool SDL_SetHint(char *name, char *value)
+    cdef SDL_bool SDL_SetHintWithPriority(char *name, char *value, SDL_HintPriority priority)
+    cdef Uint32 SDL_GetMouseState(int* x,int* y)
+    cdef Uint32 SDL_GetGlobalMouseState(int *x, int *y)
+    cdef SDL_GLContext SDL_GL_CreateContext(SDL_Window* window)
+    cdef int SDL_GetNumVideoDisplays()
+    cdef int SDL_GetNumDisplayModes(int displayIndex)
+    cdef int SDL_GetDisplayMode(int displayIndex, int index, SDL_DisplayMode * mode)
+    cdef SDL_bool SDL_HasIntersection(SDL_Rect * A, SDL_Rect * B) nogil
+    cdef SDL_bool SDL_IntersectRect(SDL_Rect * A, SDL_Rect * B, SDL_Rect * result) nogil
+    cdef void SDL_UnionRect(SDL_Rect * A, SDL_Rect * B, SDL_Rect * result) nogil
+    cdef Uint64 SDL_GetPerformanceCounter() nogil
+    cdef Uint64 SDL_GetPerformanceFrequency() nogil
+    cdef int SDL_GL_SetAttribute(SDL_GLattr attr, int value)
+    cdef int SDL_GetNumRenderDrivers()
+    cdef int SDL_GetRenderDriverInfo(int index, SDL_RendererInfo* info)
+    cdef int SDL_GL_BindTexture(SDL_Texture *texture, float *texw, float *texh)
+    cdef int SDL_GL_UnbindTexture(SDL_Texture *texture)
+    cdef int SDL_RenderReadPixels(SDL_Renderer * renderer, SDL_Rect * rect, Uint32 format, void *pixels, int pitch) nogil
+    cdef int SDL_PushEvent(SDL_Event * event) nogil
+    cdef int SDL_WaitEvent(SDL_Event * event) nogil
+
+    cdef void SDL_SetClipboardText(char * text)
+    cdef const char * SDL_GetClipboardText()
+    cdef SDL_bool SDL_HasClipboardText()
+    cdef int SDL_GetNumVideoDrivers()
+    cdef const char *SDL_GetVideoDriver(int index)
+    cdef int SDL_VideoInit(const char *driver_name)
+    cdef void SDL_VideoQuit()
+    cdef const char *SDL_GetCurrentVideoDriver()
+    cdef int SDL_GetNumVideoDisplays()
+    cdef const char * SDL_GetDisplayName(int displayIndex)
+    cdef int SDL_GetDisplayBounds(int displayIndex, SDL_Rect * rect)
+    cdef int SDL_GetNumDisplayModes(int displayIndex)
+    cdef int SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode * mode)
+    cdef int SDL_GetCurrentDisplayMode(int displayIndex, SDL_DisplayMode * mode)
+    cdef SDL_DisplayMode * SDL_GetClosestDisplayMode(int displayIndex, const SDL_DisplayMode * mode, SDL_DisplayMode * closest)
+    cdef int SDL_SetWindowDisplayMode(SDL_Window * window, SDL_DisplayMode * mode)
+    cdef int SDL_GetWindowDisplayMode(SDL_Window * window, SDL_DisplayMode * mode)
+    cdef int SDL_GetWindowDisplayIndex(SDL_Window * window)
+    cdef Uint32 SDL_GetWindowPixelFormat(SDL_Window * window)
+    cdef SDL_Window * SDL_CreateWindowFrom(const void *data)
+    cdef Uint32 SDL_GetWindowID(SDL_Window * window)
+    cdef SDL_Window * SDL_GetWindowFromID(Uint32 id)
+    cdef Uint32 SDL_GetWindowFlags(SDL_Window * window)
+    cdef void SDL_SetWindowTitle(SDL_Window * window, char *title)
+    cdef const char *SDL_GetWindowTitle(SDL_Window * window)
+    cdef void SDL_SetWindowIcon(SDL_Window * window, SDL_Surface *icon)
+    cdef void* SDL_SetWindowData(SDL_Window * window, char *name, void *data)
+    cdef void *SDL_GetWindowData(SDL_Window * window, char *name)
+    cdef void SDL_SetWindowPosition(SDL_Window * window, int x, int y)
+    cdef void SDL_GetWindowPosition(SDL_Window * window, int *x, int *y)
+    cdef void SDL_SetWindowSize(SDL_Window * window, int w, int h)
+    cdef void SDL_GetWindowSize(SDL_Window * window, int *w, int *h)
+    cdef void SDL_SetWindowMinimumSize(SDL_Window * window, int min_w, int min_h)
+    cdef void SDL_SetWindowBordered(SDL_Window * window, SDL_bool bordered)
+    cdef void SDL_ShowWindow(SDL_Window * window)
+    cdef int SDL_ShowCursor(int toggle)
+    cdef void SDL_SetCursor(SDL_Cursor * cursor)
+    cdef SDL_Cursor* SDL_CreateSystemCursor(SDL_SystemCursor id)
+    cdef void SDL_HideWindow(SDL_Window * window)
+    cdef void SDL_RaiseWindow(SDL_Window * window)
+    cdef void SDL_MaximizeWindow(SDL_Window * window)
+    cdef void SDL_MinimizeWindow(SDL_Window * window)
+    cdef void SDL_RestoreWindow(SDL_Window * window)
+    cdef int SDL_SetWindowFullscreen(SDL_Window * window, SDL_bool fullscreen)
+    cdef SDL_Surface * SDL_GetWindowSurface(SDL_Window * window)
+    cdef int SDL_UpdateWindowSurface(SDL_Window * window)
+    cdef void SDL_SetWindowGrab(SDL_Window * window, SDL_bool grabbed)
+    cdef SDL_bool SDL_GetWindowGrab(SDL_Window * window)
+    cdef int SDL_SetWindowBrightness(SDL_Window * window, float brightness)
+    cdef float SDL_GetWindowBrightness(SDL_Window * window)
+    cdef void SDL_DestroyWindow(SDL_Window * window)
+    cdef SDL_bool SDL_IsScreenSaverEnabled()
+    cdef void SDL_EnableScreenSaver()
+    cdef void SDL_DisableScreenSaver()
+    cdef int SDL_GL_LoadLibrary(const char *path)
+    cdef void *SDL_GL_GetProcAddress(const char *proc)
+    cdef void SDL_GL_UnloadLibrary()
+    cdef int SDL_GL_SetAttribute(SDL_GLattr attr, int value)
+    cdef int SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
+    cdef int SDL_GL_MakeCurrent(SDL_Window * window, SDL_GLContext context)
+    cdef SDL_Window* SDL_GL_GetCurrentWindow()
+    cdef SDL_GLContext SDL_GL_GetCurrentContext()
+    cdef int SDL_GL_SetSwapInterval(int interval)
+    cdef int SDL_GL_GetSwapInterval()
+    cdef void SDL_GL_SwapWindow(SDL_Window * window)
+    cdef void SDL_GL_DeleteContext(SDL_GLContext context)
+
+    cdef int SDL_NumJoysticks()
+    cdef SDL_Joystick * SDL_JoystickOpen(int index)
+    cdef SDL_Window * SDL_GetKeyboardFocus()
+    cdef Uint8 *SDL_GetKeyboardState(int *numkeys)
+    cdef SDL_Keymod SDL_GetModState()
+    cdef void SDL_SetModState(SDL_Keymod modstate)
+    cdef SDL_Keycode SDL_GetKeyFromScancode(SDL_Scancode scancode)
+    cdef SDL_Scancode SDL_GetScancodeFromKey(SDL_Keycode key)
+    cdef char *SDL_GetScancodeName(SDL_Scancode scancode)
+    cdef SDL_Scancode SDL_GetScancodeFromName(char *name)
+    cdef char *SDL_GetKeyName(SDL_Keycode key)
+    cdef SDL_Keycode SDL_GetKeyFromName(char *name)
+    cdef void SDL_StartTextInput()
+    cdef SDL_bool SDL_IsTextInputActive()
+    cdef void SDL_StopTextInput()
+    cdef void SDL_SetTextInputRect(SDL_Rect *rect)
+    cdef SDL_bool SDL_HasScreenKeyboardSupport()
+    cdef SDL_bool SDL_IsScreenKeyboardShown(SDL_Window *window)
+    cdef void SDL_GL_GetDrawableSize(SDL_Window *window, int *w, int *h)
+    cdef int SDL_SetWindowHitTest(SDL_Window *window, SDL_HitTest callback, void *callback_data)
+    # Sound audio formats
+    Uint16 AUDIO_U8     #0x0008  /**< Unsigned 8-bit samples */
+    Uint16 AUDIO_S8     #0x8008  /**< Signed 8-bit samples */
+    Uint16 AUDIO_U16LSB #0x0010  /**< Unsigned 16-bit samples */
+    Uint16 AUDIO_S16LSB #0x8010  /**< Signed 16-bit samples */
+    Uint16 AUDIO_U16MSB #0x1010  /**< As above, but big-endian byte order */
+    Uint16 AUDIO_S16MSB #0x9010  /**< As above, but big-endian byte order */
+    Uint16 AUDIO_U16    #AUDIO_U16LSB
+    Uint16 AUDIO_S16    #AUDIO_S16LSB
+    Uint16 AUDIO_S32LSB #0x8020  /**< 32-bit Uint16eger samples */
+    Uint16 AUDIO_S32MSB #0x9020  /**< As above, but big-endian byte order */
+    Uint16 AUDIO_S32    #AUDIO_S32LSB
+    Uint16 AUDIO_F32LSB #0x8120  /**< 32-bit floating point samples */
+    Uint16 AUDIO_F32MSB #0x9120  /**< As above, but big-endian byte order */
+    Uint16 AUDIO_F32    #AUDIO_F32LSB
+
+    # Endianness
+    Uint16 SDL_BYTEORDER
+    Uint16 SDL_LIL_ENDIAN
+    Uint16 SDL_BIG_ENDIAN
+
+cdef extern from "SDL_shape.h":
+    cdef SDL_Window * SDL_CreateShapedWindow(
+        char *title,
+        unsigned int x,
+        unsigned int y,
+        unsigned int w,
+        unsigned int h,
+        Uint32 flags
+    )
+
+    # properties, flags, etc
+    ctypedef enum WindowShapeMode:
+        ShapeModeDefault
+        ShapeModeBinarizeAlpha
+        ShapeModeReverseBinarizeAlpha
+        ShapeModeColorKey
+    ctypedef union SDL_WindowShapeParams:
+        Uint8 binarizationCutoff
+        SDL_Color colorKey
+    ctypedef struct SDL_WindowShapeMode:
+        WindowShapeMode mode
+        SDL_WindowShapeParams parameters
+
+    int SDL_NONSHAPEABLE_WINDOW
+    int SDL_INVALID_SHAPE_ARGUMENT
+    int SDL_WINDOW_LACKS_SHAPE
+
+    # set & get
+    cdef SDL_bool SDL_IsShapedWindow(SDL_Window * window)
+    int SDL_SetWindowShape(
+        SDL_Window * window,
+        SDL_Surface * shape,
+        SDL_WindowShapeMode * shape_mode
+    )
+    int SDL_GetShapedWindowMode(
+        SDL_Window * window,
+        SDL_WindowShapeMode * shape_mode
+    )
+
+cdef extern from "SDL_image.h":
+    ctypedef enum IMG_InitFlags:
+        IMG_INIT_JPG
+        IMG_INIT_PNG
+        IMG_INIT_TIF
+        IMG_INIT_WEBP
+    cdef int IMG_Init(IMG_InitFlags flags)
+    cdef char *IMG_GetError()
+    cdef SDL_Surface *IMG_Load(char *file)
+    cdef SDL_Surface *IMG_Load_RW(SDL_RWops *src, int freesrc)
+    cdef SDL_Surface *IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, char *type)
+    cdef int IMG_SavePNG(SDL_Surface *src, char *file)
+    cdef int IMG_SavePNG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst)
+    cdef int IMG_SaveJPG(SDL_Surface *surface, const char *file, int quality)
+    cdef int IMG_SaveJPG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst, int quality)
+
+
+cdef extern from "SDL_ttf.h":
+    ctypedef struct TTF_Font
+    cdef int TTF_Init()
+    cdef TTF_Font *  TTF_OpenFont( char *file, int ptsize)
+    cdef TTF_Font *  TTF_OpenFontIndex( char *file, int ptsize, long index)
+    cdef TTF_Font *  TTF_OpenFontRW(SDL_RWops *src, int freesrc, int ptsize)
+    cdef TTF_Font *  TTF_OpenFontIndexRW(SDL_RWops *src, int freesrc, int ptsize, long index)
+    #Set and retrieve the font style
+    ##define TTF_STYLE_NORMAL    0x00
+    ##define TTF_STYLE_BOLD      0x01
+    ##define TTF_STYLE_ITALIC    0x02
+    ##define TTF_STYLE_UNDERLINE 0x04
+    ##define TTF_STYLE_STRIKETHROUGH 0x08
+    cdef int TTF_STYLE_NORMAL
+    cdef int TTF_STYLE_BOLD
+    cdef int TTF_STYLE_ITALIC
+    cdef int TTF_STYLE_UNDERLINE
+    cdef int TTF_STYLE_STRIKETHROUGH
+    cdef int  TTF_GetFontStyle( TTF_Font *font)
+    cdef void  TTF_SetFontStyle(TTF_Font *font, int style)
+    cdef int  TTF_GetFontOutline( TTF_Font *font)
+    cdef void  TTF_SetFontOutline(TTF_Font *font, int outline)
+
+    #Set and retrieve FreeType hinter settings */
+    ##define TTF_HINTING_NORMAL    0
+    ##define TTF_HINTING_LIGHT     1
+    ##define TTF_HINTING_MONO      2
+    ##define TTF_HINTING_NONE      3
+    cdef int TTF_HINTING_NORMAL
+    cdef int TTF_HINTING_LIGHT
+    cdef int TTF_HINTING_MONO
+    cdef int TTF_HINTING_NONE
+    cdef int  TTF_GetFontHinting( TTF_Font *font)
+    cdef void  TTF_SetFontHinting(TTF_Font *font, int hinting)
+
+    #Get the total height of the font - usually equal to point size
+    cdef int  TTF_FontHeight( TTF_Font *font)
+
+    ## Get the offset from the baseline to the top of the font
+    #This is a positive value, relative to the baseline.
+    #*/
+    cdef int  TTF_FontAscent( TTF_Font *font)
+
+    ## Get the offset from the baseline to the bottom of the font
+    #   This is a negative value, relative to the baseline.
+    # */
+    cdef int  TTF_FontDescent( TTF_Font *font)
+
+    ## Get the recommended spacing between lines of text for this font */
+    cdef int  TTF_FontLineSkip( TTF_Font *font)
+
+    ## Get/Set whether or not kerning is allowed for this font */
+    cdef int  TTF_GetFontKerning( TTF_Font *font)
+    cdef void  TTF_SetFontKerning(TTF_Font *font, int allowed)
+
+    ## Get the number of faces of the font */
+    cdef long  TTF_FontFaces( TTF_Font *font)
+
+    ## Get the font face attributes, if any */
+    cdef int  TTF_FontFaceIsFixedWidth( TTF_Font *font)
+    cdef char *  TTF_FontFaceFamilyName( TTF_Font *font)
+    cdef char *  TTF_FontFaceStyleName( TTF_Font *font)
+
+    ## Check whether a glyph is provided by the font or not */
+    cdef int  TTF_GlyphIsProvided( TTF_Font *font, Uint16 ch)
+
+    ## Get the metrics (dimensions) of a glyph
+    #   To understand what these metrics mean, here is a useful link:
+    #    http://freetype.sourceforge.net/freetype2/docs/tutorial/step2.html
+    # */
+    cdef int  TTF_GlyphMetrics(TTF_Font *font, Uint16 ch,int *minx, int *maxx, int *miny, int *maxy, int *advance)
+
+    ## Get the dimensions of a rendered string of text */
+    cdef int  TTF_SizeText(TTF_Font *font,  char *text, int *w, int *h)
+    cdef int  TTF_SizeUTF8(TTF_Font *font,  char *text, int *w, int *h)
+    cdef int  TTF_SizeUNICODE(TTF_Font *font,  Uint16 *text, int *w, int *h)
+
+    # Create an 8-bit palettized surface and render the given text at
+    #   fast quality with the given font and color.  The 0 pixel is the
+    #   colorkey, giving a transparent background, and the 1 pixel is set
+    #   to the text color.
+    #   This function returns the new surface, or NULL if there was an error.
+    #*/
+    cdef SDL_Surface *  TTF_RenderText_Solid(TTF_Font *font, char *text, SDL_Color fg)
+    cdef SDL_Surface *  TTF_RenderUTF8_Solid(TTF_Font *font, char *text, SDL_Color fg)
+    cdef SDL_Surface *  TTF_RenderUNICODE_Solid(TTF_Font *font, Uint16 *text, SDL_Color fg)
+
+    # Create an 8-bit palettized surface and render the given glyph at
+    #   fast quality with the given font and color.  The 0 pixel is the
+    #   colorkey, giving a transparent background, and the 1 pixel is set
+    #   to the text color.  The glyph is rendered without any padding or
+    #   centering in the X direction, and aligned normally in the Y direction.
+    #   This function returns the new surface, or NULL if there was an error.
+    #*/
+    cdef SDL_Surface *  TTF_RenderGlyph_Solid(TTF_Font *font, Uint16 ch, SDL_Color fg)
+
+    # Create an 8-bit palettized surface and render the given text at
+    #   high quality with the given font and colors.  The 0 pixel is background,
+    #   while other pixels have varying degrees of the foreground color.
+    #  This function returns the new surface, or NULL if there was an error.
+    #*/
+    cdef SDL_Surface *  TTF_RenderText_Shaded(TTF_Font *font, char *text, SDL_Color fg, SDL_Color bg)
+    cdef SDL_Surface *  TTF_RenderUTF8_Shaded(TTF_Font *font, char *text, SDL_Color fg, SDL_Color bg)
+    cdef SDL_Surface *  TTF_RenderUNICODE_Shaded(TTF_Font *font, Uint16 *text, SDL_Color fg, SDL_Color bg)
+
+    # Create an 8-bit palettized surface and render the given glyph at
+    #   high quality with the given font and colors.  The 0 pixel is background,
+    #   while other pixels have varying degrees of the foreground color.
+    #   The glyph is rendered without any padding or centering in the X
+    #   direction, and aligned normally in the Y direction.
+    #   This function returns the new surface, or NULL if there was an error.
+    #
+    cdef SDL_Surface *  TTF_RenderGlyph_Shaded(TTF_Font *font,
+                    Uint16 ch, SDL_Color fg, SDL_Color bg)
+
+    # Create a 32-bit ARGB surface and render the given text at high quality,
+    #   using alpha blending to dither the font with the given color.
+    #   This function returns the new surface, or NULL if there was an error.
+    #*/
+    cdef SDL_Surface *  TTF_RenderText_Blended(TTF_Font *font,
+                     char *text, SDL_Color fg)
+    cdef SDL_Surface *  TTF_RenderUTF8_Blended(TTF_Font *font,
+                     char *text, SDL_Color fg)
+    cdef SDL_Surface *  TTF_RenderUNICODE_Blended(TTF_Font *font,
+                     Uint16 *text, SDL_Color fg)
+
+    # Create a 32-bit ARGB surface and render the given glyph at high quality,
+    #   using alpha blending to dither the font with the given color.
+    #   The glyph is rendered without any padding or centering in the X
+    #   direction, and aligned normally in the Y direction.
+    #   This function returns the new surface, or NULL if there was an error.
+    #*/
+    cdef SDL_Surface *  TTF_RenderGlyph_Blended(TTF_Font *font,
+                            Uint16 ch, SDL_Color fg)
+
+    # For compatibility with previous versions, here are the old functions */
+    ##define TTF_RenderText(font, text, fg, bg)  \
+    #    TTF_RenderText_Shaded(font, text, fg, bg)
+    ##define TTF_RenderUTF8(font, text, fg, bg)  \
+    #    TTF_RenderUTF8_Shaded(font, text, fg, bg)
+    ##define TTF_RenderUNICODE(font, text, fg, bg)   \
+    #    TTF_RenderUNICODE_Shaded(font, text, fg, bg)
+
+    # Close an opened font file */
+    cdef void  TTF_CloseFont(TTF_Font *font)
+
+    # De-initialize the TTF engine */
+    cdef void  TTF_Quit()
+
+    # Check if the TTF engine is initialized */
+    cdef int  TTF_WasInit()
+
+    # Get the kerning size of two glyphs */
+    cdef int TTF_GetFontKerningSize(TTF_Font *font, int prev_index, int index)
+
+cdef extern from "SDL_audio.h":
+    cdef int AUDIO_S16SYS
+    ctypedef struct SDL_AudioFilter:
+        pass
+    ctypedef struct SDL_AudioCVT:
+        int needed
+        int src_format
+        int dst_format
+        double rate_incr
+        Uint8 *buf
+        int len
+        int len_cvt
+        int len_mult
+        double len_ratio
+        SDL_AudioFilter filters[10]
+        int filter_index
+    cdef int SDL_BuildAudioCVT(
+        SDL_AudioCVT *cvt,
+        int src_format,
+        Uint8 src_channels,
+        int src_rate,
+        int dst_format,
+        Uint8 dst_channels,
+        int dst_rate
+    )
+    cdef int SDL_ConvertAudio(SDL_AudioCVT *cvt)
+
+cdef extern from "SDL_mixer.h":
+    cdef struct Mix_Chunk:
+        int allocated
+        Uint8 *abuf
+        Uint32 alen
+        Uint8 volume
+    ctypedef struct Mix_Music:
+        pass
+    ctypedef enum Mix_Fading:
+        MIX_NO_FADING
+        MIX_FADING_OUT
+        MIX_FADING_IN
+    ctypedef enum Mix_MusicType:
+        MUS_NONE
+        MUS_CMD
+        MUS_WAV
+        MUS_MOD
+        MUS_MID
+        MUS_OGG
+        MUS_MP3
+        MUS_MP3_MAD
+        MUS_FLAC
+        MUS_MODPLUG
+    ctypedef enum MIX_InitFlags:
+        MIX_INIT_FLAC        = 0x00000001
+        MIX_INIT_MOD         = 0x00000002
+        MIX_INIT_MODPLUG     = 0x00000004 # Removed in mixer 2.0.2
+        MIX_INIT_MP3         = 0x00000008
+        MIX_INIT_OGG         = 0x00000010
+        MIX_INIT_MID         = 0x00000020 # Previously _FLUIDSYNTH
+
+    cdef int MIX_MAX_VOLUME
+
+
+    cdef int Mix_Init(int flags)
+    cdef void Mix_Quit()
+    cdef int Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize)
+    cdef  int  Mix_AllocateChannels(int numchans)
+    cdef  int  Mix_QuerySpec(int *frequency,Uint16 *format,int *channels)
+    cdef  Mix_Chunk *  Mix_LoadWAV_RW(SDL_RWops *src, int freesrc)
+    cdef  Mix_Chunk *  Mix_LoadWAV(char *file)
+    cdef  Mix_Music *  Mix_LoadMUS(char *file)
+    cdef  Mix_Music *  Mix_LoadMUS_RW(SDL_RWops *rw)
+    cdef  Mix_Music *  Mix_LoadMUSType_RW(SDL_RWops *rw, Mix_MusicType type, int freesrc)
+    cdef  Mix_Chunk *  Mix_QuickLoad_WAV(Uint8 *mem)
+    cdef  Mix_Chunk *  Mix_QuickLoad_RAW(Uint8 *mem, Uint32 len)
+    cdef  void  Mix_FreeChunk(Mix_Chunk *chunk)
+    cdef  void  Mix_FreeMusic(Mix_Music *music)
+    cdef int  Mix_GetNumChunkDecoders()
+    cdef  char *  Mix_GetChunkDecoder(int index)
+    cdef int  Mix_GetNumMusicDecoders()
+    cdef  char *  Mix_GetMusicDecoder(int index)
+    cdef Mix_MusicType  Mix_GetMusicType( Mix_Music *music)
+    cdef void  Mix_SetPostMix(void (*mix_func)(void *udata, Uint8 *stream, int len), void *arg)
+    cdef void  Mix_HookMusic(void (*mix_func) (void *udata, Uint8 *stream, int len), void *arg)
+    cdef void  Mix_HookMusicFinished(void (*music_finished)())
+    cdef void *  Mix_GetMusicHookData()
+    cdef void  Mix_ChannelFinished(void (*channel_finished)(int channel))
+    #    typedef void (*Mix_EffectFunc_t)(int chan, void *stream, int len, void *udata)
+    #    typedef void (*Mix_EffectDone_t)(int chan, void *udata)
+    #    cdef int  Mix_RegisterEffect(int chan, Mix_EffectFunc_t f,
+    #    cdef int  Mix_UnregisterEffect(int channel, Mix_EffectFunc_t f)
+    cdef int  Mix_UnregisterAllEffects(int channel)
+    cdef int Mix_SetPanning(int channel, Uint8 left, Uint8 right)
+    cdef int  Mix_SetPosition(int channel, Sint16 angle, Uint8 distance)
+    cdef int  Mix_SetDistance(int channel, Uint8 distance)
+    cdef int  Mix_SetReverseStereo(int channel, int flip)
+    cdef int  Mix_ReserveChannels(int num)
+    cdef int  Mix_GroupChannel(int which, int tag)
+    cdef int  Mix_GroupChannels(int _from, int to, int tag)
+    cdef int  Mix_GroupAvailable(int tag)
+    cdef int  Mix_GroupCount(int tag)
+    cdef int  Mix_GroupOldest(int tag)
+    cdef int  Mix_GroupNewer(int tag)
+    cdef int  Mix_PlayChannel(int channel, Mix_Chunk *chunk, int loops)
+    cdef int  Mix_PlayChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ticks)
+    cdef int  Mix_PlayMusic(Mix_Music *music, int loops)
+    cdef int  Mix_FadeInMusic(Mix_Music *music, int loops, int ms)
+    cdef int  Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double position)
+    cdef int  Mix_FadeInChannel(int channel, Mix_Chunk *chunk, int loops, int ms)
+    cdef int  Mix_FadeInChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ms, int ticks)
+    cdef int  Mix_Volume(int channel, int volume)
+    cdef int  Mix_VolumeChunk(Mix_Chunk *chunk, int volume)
+    cdef int  Mix_VolumeMusic(int volume)
+    cdef int  Mix_HaltChannel(int channel)
+    cdef int  Mix_HaltGroup(int tag)
+    cdef int  Mix_HaltMusic()
+    cdef int  Mix_ExpireChannel(int channel, int ticks)
+    cdef int  Mix_FadeOutChannel(int which, int ms)
+    cdef int  Mix_FadeOutGroup(int tag, int ms)
+    cdef int  Mix_FadeOutMusic(int ms)
+    cdef Mix_Fading  Mix_FadingMusic()
+    cdef Mix_Fading  Mix_FadingChannel(int which)
+    cdef void  Mix_Pause(int channel)
+    cdef void  Mix_Resume(int channel)
+    cdef int  Mix_Paused(int channel)
+    cdef void  Mix_PauseMusic()
+    cdef void  Mix_ResumeMusic()
+    cdef void  Mix_RewindMusic()
+    cdef int  Mix_PausedMusic()
+    cdef int  Mix_SetMusicPosition(double position)
+    cdef int  Mix_Playing(int channel)
+    cdef int  Mix_PlayingMusic()
+    cdef int  Mix_SetMusicCMD( char *command)
+    cdef int  Mix_SetSynchroValue(int value)
+    cdef int  Mix_GetSynchroValue()
+    cdef int  Mix_SetSoundFonts( char *paths)
+    cdef  char*  Mix_GetSoundFonts()
+    #cdef int  Mix_EachSoundFont(int (*function)( char*, void*), void *data)
+    cdef Mix_Chunk *  Mix_GetChunk(int channel)
+    cdef void  Mix_CloseAudio()
+    cdef char * Mix_GetError()
+
+include '../core/window/window_attrs.pxi'
+cdef extern from "SDL_syswm.h":
+    cdef enum SDL_SYSWM_TYPE:
+        SDL_SYSWM_UNKNOWN
+        SDL_SYSWM_WINDOWS
+        SDL_SYSWM_X11
+        SDL_SYSWM_DIRECTFB
+        SDL_SYSWM_COCOA
+        SDL_SYSWM_UIKIT
+        SDL_SYSWM_WAYLAND
+        SDL_SYSWM_MIR
+        SDL_SYSWM_WINRT
+        SDL_SYSWM_ANDROID
+        SDL_SYSWM_VIVANTE
+        SDL_SYSWM_OS2
+
+    IF UNAME_SYSNAME == 'Windows':
+        cdef struct _wm_info_win:
+            HWND window
+            HDC hdc
+    ELSE:
+        cdef struct _wm_info_win:
+            int dummy
+
+    IF USE_WAYLAND:
+        cdef struct _wm_info_wl:
+            wl_display *display
+            wl_surface *surface
+            wl_shell_surface *shell_surface
+    ELSE:
+        cdef struct _wm_info_wl:
+            int dummy
+
+    IF USE_X11:
+        cdef struct _wm_info_x11:
+            Display *display
+            Window window
+    ELSE:
+       cdef struct _wm_info_x11:
+           int dummy
+
+    cdef union _wm_info:
+        _wm_info_win win
+        _wm_info_wl wl
+        _wm_info_x11 x11
+
+    cdef struct SDL_SysWMinfo:
+        SDL_version version
+        SDL_SYSWM_TYPE subsystem
+        _wm_info info
+
+    cdef SDL_bool SDL_GetWindowWMInfo(SDL_Window *window, SDL_SysWMinfo *info)
diff --git a/kivy/lib/vidcore_lite/__init__.py b/kivy/lib/vidcore_lite/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/kivy/lib/vidcore_lite/__pycache__/__init__.cpython-310.pyc b/kivy/lib/vidcore_lite/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..cea857a
Binary files /dev/null and b/kivy/lib/vidcore_lite/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/lib/vidcore_lite/bcm.pxd b/kivy/lib/vidcore_lite/bcm.pxd
new file mode 100644
index 0000000..a2dcf49
--- /dev/null
+++ b/kivy/lib/vidcore_lite/bcm.pxd
@@ -0,0 +1,70 @@
+
+
+cdef extern from "bcm_host.h":
+    ctypedef int int32_t
+    ctypedef unsigned short int	uint16_t
+    ctypedef unsigned int		uint32_t
+    
+    ctypedef uint32_t DISPMANX_DISPLAY_HANDLE_T
+    ctypedef uint32_t DISPMANX_UPDATE_HANDLE_T
+    ctypedef uint32_t DISPMANX_ELEMENT_HANDLE_T
+    ctypedef uint32_t DISPMANX_RESOURCE_HANDLE_T
+    ctypedef uint32_t DISPMANX_PROTECTION_T
+    
+    struct tag_VC_RECT_T:
+        int32_t x
+        int32_t y
+        int32_t width
+        int32_t height
+        
+    ctypedef tag_VC_RECT_T VC_RECT_T
+        
+    ctypedef enum DISPMANX_TRANSFORM_T:
+        pass
+        
+    ctypedef struct DISPMANX_CLAMP_T:
+        pass
+        
+    ctypedef struct VC_DISPMANX_ALPHA_T:
+        pass
+    
+    void bcm_host_init()
+    void bcm_host_deinit()
+    
+    int32_t c_get_display_size "graphics_get_display_size" (uint16_t display_number,
+                                      uint32_t *width, uint32_t *height)
+    DISPMANX_DISPLAY_HANDLE_T vc_dispmanx_display_open( uint32_t device )
+    DISPMANX_UPDATE_HANDLE_T vc_dispmanx_update_start( int32_t priority )
+    DISPMANX_ELEMENT_HANDLE_T vc_dispmanx_element_add ( DISPMANX_UPDATE_HANDLE_T update, 
+                                                        DISPMANX_DISPLAY_HANDLE_T display,
+                                                        int32_t layer, 
+                                                        VC_RECT_T *dest_rect, 
+                                                        DISPMANX_RESOURCE_HANDLE_T src,
+                                                        VC_RECT_T *src_rect, 
+                                                        DISPMANX_PROTECTION_T protection, 
+                                                        VC_DISPMANX_ALPHA_T *alpha,
+                                                        DISPMANX_CLAMP_T *clamp, 
+                                                        DISPMANX_TRANSFORM_T transform )
+    int vc_dispmanx_update_submit_sync( DISPMANX_UPDATE_HANDLE_T update )
+
+cdef public uint32_t DISPMANX_PROTECTION_NONE = 0
+
+cdef class Rect:
+    cdef:
+        VC_RECT_T _vc_rect
+
+
+cdef class DisplayHandle:
+    cdef DISPMANX_DISPLAY_HANDLE_T _handle
+    
+cdef class UpdateHandle:
+    cdef DISPMANX_UPDATE_HANDLE_T _handle
+    
+cdef class ResourceHandle:
+    cdef DISPMANX_RESOURCE_HANDLE_T _handle
+    
+cdef class ProtectionHandle:
+    cdef DISPMANX_PROTECTION_T _handle
+    
+cdef class ElementHandle:
+    cdef DISPMANX_ELEMENT_HANDLE_T _handle
diff --git a/kivy/loader.py b/kivy/loader.py
new file mode 100644
index 0000000..500eb96
--- /dev/null
+++ b/kivy/loader.py
@@ -0,0 +1,582 @@
+'''
+Asynchronous data loader
+========================
+
+This is the Asynchronous Loader. You can use it to load an image
+and use it, even if data are not yet available. You must specify a default
+loading image when using the loader::
+
+    from kivy.loader import Loader
+    image = Loader.image('mysprite.png')
+
+You can also load an image from a url::
+
+    image = Loader.image('http://mysite.com/test.png')
+
+If you want to change the default loading image, you can do::
+
+    Loader.loading_image = Image('another_loading.png')
+
+Tweaking the asynchronous loader
+--------------------------------
+
+.. versionadded:: 1.6.0
+
+You can tweak the loader to provide a better user experience or more
+performance, depending of the images you are going to load. Take a look at the
+parameters:
+
+- :attr:`Loader.num_workers` - define the number of threads to start for
+  loading images.
+- :attr:`Loader.max_upload_per_frame` - define the maximum image uploads in
+  GPU to do per frame.
+
+'''
+
+__all__ = ('Loader', 'LoaderBase', 'ProxyImage')
+
+from kivy import kivy_data_dir
+from kivy.logger import Logger
+from kivy.clock import Clock
+from kivy.cache import Cache
+from kivy.core.image import ImageLoader, Image
+from kivy.compat import PY2, string_types
+from kivy.config import Config
+from kivy.utils import platform
+
+from collections import deque
+from time import sleep
+from os.path import join
+from os import write, close, unlink, environ
+import threading
+import mimetypes
+
+
+# Register a cache for loader
+Cache.register('kv.loader', limit=500, timeout=60)
+
+
+class ProxyImage(Image):
+    '''Image returned by the Loader.image() function.
+
+    :Properties:
+        `loaded`: bool, defaults to False
+            This value may be True if the image is already cached.
+
+    :Events:
+        `on_load`
+            Fired when the image is loaded or changed.
+        `on_error`
+            Fired when the image cannot be loaded.
+            `error`: Exception data that occurred
+    '''
+
+    __events__ = ('on_load', 'on_error')
+
+    def __init__(self, arg, **kwargs):
+        loaded = kwargs.pop('loaded', False)
+        super(ProxyImage, self).__init__(arg, **kwargs)
+        self.loaded = loaded
+
+    def on_load(self):
+        pass
+
+    def on_error(self, error):
+        pass
+
+
+class LoaderBase(object):
+    '''Common base for the Loader and specific implementations.
+    By default, the Loader will be the best available loader implementation.
+
+    The _update() function is called every 1 / 25.s or each frame if we have
+    less than 25 FPS.
+    '''
+    _trigger_update = None
+
+    '''Alias for mimetype extensions.
+
+    If you have trouble to have the right extension to be detected,
+    you can either add #.EXT at the end of the url, or use this array
+    to correct the detection.
+    For example, a zip-file on Windows can be detected as pyz.
+
+    By default, '.pyz' is translated to '.zip'
+
+    .. versionadded:: 1.11.0
+    '''
+    EXT_ALIAS = {
+        '.pyz': '.zip'
+    }
+
+    def __init__(self):
+        self._loading_image = None
+        self._error_image = None
+        self._num_workers = 2
+        self._max_upload_per_frame = 2
+        self._paused = False
+        self._resume_cond = threading.Condition()
+
+        self._q_load = deque()
+        self._q_done = deque()
+        self._client = []
+        self._running = False
+        self._start_wanted = False
+        self._trigger_update = Clock.create_trigger(self._update)
+
+        if platform in ['android', 'ios']:
+            import certifi
+            environ.setdefault('SSL_CERT_FILE', certifi.where())
+
+    def __del__(self):
+        if self._trigger_update is not None:
+            self._trigger_update.cancel()
+
+    def _set_num_workers(self, num):
+        if num < 2:
+            raise Exception('Must have at least 2 workers')
+        self._num_workers = num
+
+    def _get_num_workers(self):
+        return self._num_workers
+
+    num_workers = property(_get_num_workers, _set_num_workers)
+    '''Number of workers to use while loading (used only if the loader
+    implementation supports it). This setting impacts the loader only on
+    initialization. Once the loader is started, the setting has no impact::
+
+        from kivy.loader import Loader
+        Loader.num_workers = 4
+
+    The default value is 2 for giving a smooth user experience. You could
+    increase the number of workers, then all the images will be loaded faster,
+    but the user will not been able to use the application while loading.
+    Prior to 1.6.0, the default number was 20, and loading many full-hd images
+    was completely blocking the application.
+
+    .. versionadded:: 1.6.0
+    '''
+
+    def _set_max_upload_per_frame(self, num):
+        if num is not None and num < 1:
+            raise Exception('Must have at least 1 image processing per image')
+        self._max_upload_per_frame = num
+
+    def _get_max_upload_per_frame(self):
+        return self._max_upload_per_frame
+
+    max_upload_per_frame = property(_get_max_upload_per_frame,
+                                    _set_max_upload_per_frame)
+    '''The number of images to upload per frame. By default, we'll
+    upload only 2 images to the GPU per frame. If you are uploading many
+    small images, you can easily increase this parameter to 10 or more.
+    If you are loading multiple full HD images, the upload time may have
+    consequences and block the application. If you want a
+    smooth experience, use the default.
+
+    As a matter of fact, a Full-HD RGB image will take ~6MB in memory,
+    so it may take time. If you have activated mipmap=True too, then the
+    GPU must calculate the mipmap of these big images too, in real time.
+    Then it may be best to reduce the :attr:`max_upload_per_frame` to 1
+    or 2. If you want to get rid of that (or reduce it a lot), take a
+    look at the DDS format.
+
+    .. versionadded:: 1.6.0
+    '''
+
+    def _get_loading_image(self):
+        if not self._loading_image:
+            loading_png_fn = join(kivy_data_dir, 'images', 'image-loading.zip')
+            self._loading_image = ImageLoader.load(filename=loading_png_fn)
+        return self._loading_image
+
+    def _set_loading_image(self, image):
+        if isinstance(image, string_types):
+            self._loading_image = ImageLoader.load(filename=image)
+        else:
+            self._loading_image = image
+
+    loading_image = property(_get_loading_image, _set_loading_image)
+    '''Image used for loading.
+    You can change it by doing::
+
+        Loader.loading_image = 'loading.png'
+
+    .. versionchanged:: 1.6.0
+        Not readonly anymore.
+    '''
+
+    def _get_error_image(self):
+        if not self._error_image:
+            error_png_fn = join(
+                'atlas://data/images/defaulttheme/image-missing')
+            self._error_image = ImageLoader.load(filename=error_png_fn)
+        return self._error_image
+
+    def _set_error_image(self, image):
+        if isinstance(image, string_types):
+            self._error_image = ImageLoader.load(filename=image)
+        else:
+            self._error_image = image
+
+    error_image = property(_get_error_image, _set_error_image)
+    '''Image used for error.
+    You can change it by doing::
+
+        Loader.error_image = 'error.png'
+
+    .. versionchanged:: 1.6.0
+        Not readonly anymore.
+    '''
+
+    def start(self):
+        '''Start the loader thread/process.'''
+        self._running = True
+
+    def run(self, *largs):
+        '''Main loop for the loader.'''
+        pass
+
+    def stop(self):
+        '''Stop the loader thread/process.'''
+        self._running = False
+
+    def pause(self):
+        '''Pause the loader, can be useful during interactions.
+
+        .. versionadded:: 1.6.0
+        '''
+        self._paused = True
+
+    def resume(self):
+        '''Resume the loader, after a :meth:`pause`.
+
+        .. versionadded:: 1.6.0
+        '''
+        self._paused = False
+        self._resume_cond.acquire()
+        self._resume_cond.notify_all()
+        self._resume_cond.release()
+
+    def _wait_for_resume(self):
+        while self._running and self._paused:
+            self._resume_cond.acquire()
+            self._resume_cond.wait(0.25)
+            self._resume_cond.release()
+
+    def _load(self, kwargs):
+        '''(internal) Loading function, called by the thread.
+        Will call _load_local() if the file is local,
+        or _load_urllib() if the file is on Internet.
+        '''
+
+        while len(self._q_done) >= (
+                self.max_upload_per_frame * self._num_workers):
+            sleep(0.1)
+
+        self._wait_for_resume()
+
+        filename = kwargs['filename']
+        load_callback = kwargs['load_callback']
+        post_callback = kwargs['post_callback']
+        try:
+            proto = filename.split(':', 1)[0]
+        except:
+            # if blank filename then return
+            return
+        if load_callback is not None:
+            data = load_callback(filename)
+        elif proto in ('http', 'https', 'ftp', 'smb'):
+            data = self._load_urllib(filename, kwargs['kwargs'])
+        else:
+            data = self._load_local(filename, kwargs['kwargs'])
+
+        if post_callback:
+            data = post_callback(data)
+
+        self._q_done.appendleft((filename, data))
+        self._trigger_update()
+
+    def _load_local(self, filename, kwargs):
+        '''(internal) Loading a local file'''
+        # With recent changes to CoreImage, we must keep data otherwise,
+        # we might be unable to recreate the texture afterwise.
+        return ImageLoader.load(filename, keep_data=True, **kwargs)
+
+    def _load_urllib(self, filename, kwargs):
+        '''(internal) Loading a network file. First download it, save it to a
+        temporary file, and pass it to _load_local().'''
+        if PY2:
+            import urllib2 as urllib_request
+
+            def gettype(info):
+                return info.gettype()
+        else:
+            import urllib.request as urllib_request
+
+            def gettype(info):
+                return info.get_content_type()
+        proto = filename.split(':', 1)[0]
+        if proto == 'smb':
+            try:
+                # note: it's important to load SMBHandler every time
+                # otherwise the data is occasionally not loaded
+                from smb.SMBHandler import SMBHandler
+            except ImportError:
+                Logger.warning(
+                    'Loader: can not load PySMB: make sure it is installed')
+                return
+        import tempfile
+        data = fd = _out_osfd = None
+        try:
+            _out_filename = ''
+
+            if proto == 'smb':
+                # read from samba shares
+                fd = urllib_request.build_opener(SMBHandler).open(filename)
+            else:
+                # read from internet
+                request = urllib_request.Request(filename)
+                if Config.has_option('network', 'useragent'):
+                    useragent = Config.get('network', 'useragent')
+                    if useragent:
+                        request.add_header('User-Agent', useragent)
+                opener = urllib_request.build_opener()
+                fd = opener.open(request)
+
+            if '#.' in filename:
+                # allow extension override from URL fragment
+                suffix = '.' + filename.split('#.')[-1]
+            else:
+                ctype = gettype(fd.info())
+                suffix = mimetypes.guess_extension(ctype)
+                suffix = LoaderBase.EXT_ALIAS.get(suffix, suffix)
+                if not suffix:
+                    # strip query string and split on path
+                    parts = filename.split('?')[0].split('/')[1:]
+                    while len(parts) > 1 and not parts[0]:
+                        # strip out blanks from '//'
+                        parts = parts[1:]
+                    if len(parts) > 1 and '.' in parts[-1]:
+                        # we don't want '.com', '.net', etc. as the extension
+                        suffix = '.' + parts[-1].split('.')[-1]
+            _out_osfd, _out_filename = tempfile.mkstemp(
+                prefix='kivyloader', suffix=suffix)
+
+            idata = fd.read()
+            fd.close()
+            fd = None
+
+            # write to local filename
+            write(_out_osfd, idata)
+            close(_out_osfd)
+            _out_osfd = None
+
+            # load data
+            data = self._load_local(_out_filename, kwargs)
+
+            # FIXME create a clean API for that
+            for imdata in data._data:
+                imdata.source = filename
+        except Exception as ex:
+            Logger.exception('Loader: Failed to load image <%s>' % filename)
+            # close file when remote file not found or download error
+            try:
+                if _out_osfd:
+                    close(_out_osfd)
+            except OSError:
+                pass
+
+            # update client
+            for c_filename, client in self._client[:]:
+                if filename != c_filename:
+                    continue
+                # got one client to update
+                client.image = self.error_image
+                client.dispatch('on_error', error=ex)
+                self._client.remove((c_filename, client))
+
+            return self.error_image
+        finally:
+            if fd:
+                fd.close()
+            if _out_osfd:
+                close(_out_osfd)
+            if _out_filename != '':
+                unlink(_out_filename)
+
+        return data
+
+    def _update(self, *largs):
+        '''(internal) Check if a data is loaded, and pass to the client.'''
+        # want to start it ?
+        if self._start_wanted:
+            if not self._running:
+                self.start()
+            self._start_wanted = False
+
+        # in pause mode, don't unqueue anything.
+        if self._paused:
+            self._trigger_update()
+            return
+
+        for x in range(self.max_upload_per_frame):
+            try:
+                filename, data = self._q_done.pop()
+            except IndexError:
+                return
+
+            # create the image
+            image = data  # ProxyImage(data)
+            if not image.nocache:
+                Cache.append('kv.loader', filename, image)
+
+            # update client
+            for c_filename, client in self._client[:]:
+                if filename != c_filename:
+                    continue
+                # got one client to update
+                client.image = image
+                client.loaded = True
+                client.dispatch('on_load')
+                self._client.remove((c_filename, client))
+
+        self._trigger_update()
+
+    def image(self, filename, load_callback=None, post_callback=None,
+              **kwargs):
+        '''Load a image using the Loader. A ProxyImage is returned with a
+        loading image. You can use it as follows::
+
+            from kivy.app import App
+            from kivy.uix.image import Image
+            from kivy.loader import Loader
+
+            class TestApp(App):
+                def _image_loaded(self, proxyImage):
+                    if proxyImage.image.texture:
+                        self.image.texture = proxyImage.image.texture
+
+                def build(self):
+                    proxyImage = Loader.image("myPic.jpg")
+                    proxyImage.bind(on_load=self._image_loaded)
+                    self.image = Image()
+                    return self.image
+
+            TestApp().run()
+
+        In order to cancel all background loading, call *Loader.stop()*.
+        '''
+        data = Cache.get('kv.loader', filename)
+        if data not in (None, False):
+            # found image, if data is not here, need to reload.
+            return ProxyImage(data,
+                              loading_image=self.loading_image,
+                              loaded=True, **kwargs)
+
+        client = ProxyImage(self.loading_image,
+                            loading_image=self.loading_image, **kwargs)
+        self._client.append((filename, client))
+
+        if data is None:
+            # if data is None, this is really the first time
+            self._q_load.appendleft({
+                'filename': filename,
+                'load_callback': load_callback,
+                'post_callback': post_callback,
+                'kwargs': kwargs})
+            if not kwargs.get('nocache', False):
+                Cache.append('kv.loader', filename, False)
+            self._start_wanted = True
+            self._trigger_update()
+        else:
+            # already queued for loading
+            pass
+
+        return client
+
+    def remove_from_cache(self, filename):
+        Cache.remove('kv.loader', filename)
+
+#
+# Loader implementation
+#
+
+
+if 'KIVY_DOC' in environ:
+
+    Loader = None
+
+else:
+
+    #
+    # Try to use pygame as our first choice for loader
+    #
+
+    from kivy.compat import queue
+    from threading import Thread
+
+    class _Worker(Thread):
+        '''Thread executing tasks from a given tasks queue
+        '''
+        def __init__(self, pool, tasks):
+            Thread.__init__(self)
+            self.tasks = tasks
+            self.daemon = True
+            self.pool = pool
+            self.start()
+
+        def run(self):
+            while self.pool.running:
+                func, args, kargs = self.tasks.get()
+                try:
+                    func(*args, **kargs)
+                except Exception as e:
+                    print(e)
+                self.tasks.task_done()
+
+    class _ThreadPool(object):
+        '''Pool of threads consuming tasks from a queue
+        '''
+        def __init__(self, num_threads):
+            super(_ThreadPool, self).__init__()
+            self.running = True
+            self.tasks = queue.Queue()
+            for _ in range(num_threads):
+                _Worker(self, self.tasks)
+
+        def add_task(self, func, *args, **kargs):
+            '''Add a task to the queue
+            '''
+            self.tasks.put((func, args, kargs))
+
+        def stop(self):
+            self.running = False
+            self.tasks.join()
+
+    class LoaderThreadPool(LoaderBase):
+        def __init__(self):
+            super(LoaderThreadPool, self).__init__()
+            self.pool = None
+
+        def start(self):
+            super(LoaderThreadPool, self).start()
+            self.pool = _ThreadPool(self._num_workers)
+            Clock.schedule_interval(self.run, 0)
+
+        def stop(self):
+            super(LoaderThreadPool, self).stop()
+            Clock.unschedule(self.run)
+            self.pool.stop()
+
+        def run(self, *largs):
+            while self._running:
+                try:
+                    parameters = self._q_load.pop()
+                except:
+                    return
+                self.pool.add_task(self._load, parameters)
+
+    Loader = LoaderThreadPool()
+    Logger.info('Loader: using a thread pool of {} workers'.format(
+        Loader.num_workers))
diff --git a/kivy/logger.py b/kivy/logger.py
new file mode 100644
index 0000000..b9d664c
--- /dev/null
+++ b/kivy/logger.py
@@ -0,0 +1,405 @@
+'''
+Logger object
+=============
+
+The Kivy `Logger` class provides a singleton logger instance. This instance
+exposes a standard Python
+`logger <https://docs.python.org/3/library/logging.html>`_ object but adds
+some convenient features.
+
+All the standard logging levels are available : `trace`, `debug`, `info`,
+`warning`, `error` and `critical`.
+
+Example Usage
+-------------
+
+Use the `Logger` as you would a standard Python logger. ::
+
+    from kivy.logger import Logger
+
+    Logger.info('title: This is a info message.')
+    Logger.debug('title: This is a debug message.')
+
+    try:
+        raise Exception('bleh')
+    except Exception:
+        Logger.exception('Something happened!')
+
+The message passed to the logger is split into two parts separated by a colon
+(:). The first part is used as a title and the second part is used as the
+message. This way, you can "categorize" your messages easily. ::
+
+    Logger.info('Application: This is a test')
+
+    # will appear as
+
+    [INFO   ] [Application ] This is a test
+
+You can change the logging level at any time using the `setLevel` method. ::
+
+    from kivy.logger import Logger, LOG_LEVELS
+
+    Logger.setLevel(LOG_LEVELS["debug"])
+
+
+Features
+--------
+
+Although you are free to use standard python loggers, the Kivy `Logger` offers
+some solid benefits and useful features. These include:
+
+* simplied usage (single instance, simple configuration, works by default)
+* color-coded output
+* output to `stdout` by default
+* message categorization via colon separation
+* access to log history even if logging is disabled
+* built-in handling of various cross-platform considerations
+
+Kivys' logger was designed to be used with kivy apps and makes logging from
+Kivy apps more convenient.
+
+Logger Configuration
+--------------------
+
+The Logger can be controlled via the Kivy configuration file::
+
+    [kivy]
+    log_level = info
+    log_enable = 1
+    log_dir = logs
+    log_name = kivy_%y-%m-%d_%_.txt
+    log_maxfiles = 100
+
+More information about the allowed values are described in the
+:mod:`kivy.config` module.
+
+Logger History
+--------------
+
+Even if the logger is not enabled, you still have access to the last 100
+messages::
+
+    from kivy.logger import LoggerHistory
+
+    print(LoggerHistory.history)
+
+'''
+
+import logging
+import os
+import sys
+import copy
+from random import randint
+from functools import partial
+import pathlib
+
+import kivy
+
+
+__all__ = (
+    'Logger', 'LOG_LEVELS', 'COLORS', 'LoggerHistory', 'file_log_handler')
+
+try:
+    PermissionError
+except NameError:  # Python 2
+    PermissionError = OSError, IOError
+
+Logger = None
+
+BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = list(range(8))
+
+# These are the sequences need to get colored output
+RESET_SEQ = "\033[0m"
+COLOR_SEQ = "\033[1;%dm"
+BOLD_SEQ = "\033[1m"
+
+previous_stderr = sys.stderr
+
+
+def formatter_message(message, use_color=True):
+    if use_color:
+        message = message.replace("$RESET", RESET_SEQ)
+        message = message.replace("$BOLD", BOLD_SEQ)
+    else:
+        message = message.replace("$RESET", "").replace("$BOLD", "")
+    return message
+
+
+COLORS = {
+    'TRACE': MAGENTA,
+    'WARNING': YELLOW,
+    'INFO': GREEN,
+    'DEBUG': CYAN,
+    'CRITICAL': RED,
+    'ERROR': RED}
+
+logging.TRACE = 9
+LOG_LEVELS = {
+    'trace': logging.TRACE,
+    'debug': logging.DEBUG,
+    'info': logging.INFO,
+    'warning': logging.WARNING,
+    'error': logging.ERROR,
+    'critical': logging.CRITICAL}
+
+
+class FileHandler(logging.Handler):
+    history = []
+    filename = 'log.txt'
+    fd = None
+    log_dir = ''
+    encoding = 'utf-8'
+
+    def purge_logs(self):
+        """Purge logs which exceed the maximum amount of log files,
+        starting with the oldest creation timestamp (or edit-timestamp on Linux)
+        """
+
+        if not self.log_dir:
+            return
+
+        from kivy.config import Config
+        maxfiles = Config.getint("kivy", "log_maxfiles")
+
+        # Get path to log directory
+        log_dir = pathlib.Path(self.log_dir)
+
+        if maxfiles < 0:  # No log file limit set
+            return
+
+        Logger.info("Logger: Purge log fired. Processing...")
+
+        # Get all files from log directory and corresponding creation timestamps
+        files = [(item, item.stat().st_ctime)
+                 for item in log_dir.iterdir() if item.is_file()]
+        # Sort files by ascending timestamp
+        files.sort(key=lambda x: x[1])
+
+        for file, _ in files[:(-maxfiles or len(files))]:
+            # More log files than allowed maximum,
+            # delete files, starting with oldest creation timestamp
+            # (or edit-timestamp on Linux)
+            try:
+                file.unlink()
+            except (PermissionError, FileNotFoundError) as e:
+                Logger.info(f"Logger: Skipped file {file}, {repr(e)}")
+
+        Logger.info("Logger: Purge finished!")
+
+    def _configure(self, *largs, **kwargs):
+        from time import strftime
+        from kivy.config import Config
+        log_dir = Config.get('kivy', 'log_dir')
+        log_name = Config.get('kivy', 'log_name')
+
+        _dir = kivy.kivy_home_dir
+        if log_dir and os.path.isabs(log_dir):
+            _dir = log_dir
+        else:
+            _dir = os.path.join(_dir, log_dir)
+        if not os.path.exists(_dir):
+            os.makedirs(_dir)
+        self.log_dir = _dir
+
+        pattern = log_name.replace('%_', '@@NUMBER@@')
+        pattern = os.path.join(_dir, strftime(pattern))
+        n = 0
+        while True:
+            filename = pattern.replace('@@NUMBER@@', str(n))
+            if not os.path.exists(filename):
+                break
+            n += 1
+            if n > 10000:  # prevent maybe flooding ?
+                raise Exception('Too many logfile, remove them')
+
+        if FileHandler.filename == filename and FileHandler.fd is not None:
+            return
+
+        FileHandler.filename = filename
+        if FileHandler.fd not in (None, False):
+            FileHandler.fd.close()
+        FileHandler.fd = open(filename, 'w', encoding=FileHandler.encoding)
+        Logger.info('Logger: Record log in %s' % filename)
+
+    def _write_message(self, record):
+        if FileHandler.fd in (None, False):
+            return
+
+        msg = self.format(record)
+        stream = FileHandler.fd
+        fs = "%s\n"
+        stream.write('[%-7s] ' % record.levelname)
+        stream.write(fs % msg)
+        stream.flush()
+
+    def emit(self, message):
+        # during the startup, store the message in the history
+        if Logger.logfile_activated is None:
+            FileHandler.history += [message]
+            return
+
+        # startup done, if the logfile is not activated, avoid history.
+        if Logger.logfile_activated is False:
+            FileHandler.history = []
+            return
+
+        if FileHandler.fd is None:
+            try:
+                self._configure()
+                from kivy.config import Config
+                Config.add_callback(self._configure, 'kivy', 'log_dir')
+                Config.add_callback(self._configure, 'kivy', 'log_name')
+            except Exception:
+                # deactivate filehandler...
+                if FileHandler.fd not in (None, False):
+                    FileHandler.fd.close()
+                FileHandler.fd = False
+                Logger.exception('Error while activating FileHandler logger')
+                return
+            while FileHandler.history:
+                _message = FileHandler.history.pop()
+                self._write_message(_message)
+
+        self._write_message(message)
+
+
+class LoggerHistory(logging.Handler):
+
+    history = []
+
+    def emit(self, message):
+        LoggerHistory.history = [message] + LoggerHistory.history[:100]
+
+    @classmethod
+    def clear_history(cls):
+        del cls.history[:]
+
+    def flush(self):
+        super(LoggerHistory, self).flush()
+        self.clear_history()
+
+
+class ColoredFormatter(logging.Formatter):
+
+    def __init__(self, msg, use_color=True):
+        logging.Formatter.__init__(self, msg)
+        self.use_color = use_color
+
+    def format(self, record):
+        """Apply terminal color code to the record"""
+        # deepcopy so we do not mess up the record for other formatters
+        record = copy.deepcopy(record)
+        try:
+            msg = record.msg.split(':', 1)
+            if len(msg) == 2:
+                record.msg = '[%-12s]%s' % (msg[0], msg[1])
+        except:
+            pass
+        levelname = record.levelname
+        if record.levelno == logging.TRACE:
+            levelname = 'TRACE'
+            record.levelname = levelname
+        if self.use_color and levelname in COLORS:
+            levelname_color = (
+                COLOR_SEQ % (30 + COLORS[levelname]) + levelname + RESET_SEQ)
+            record.levelname = levelname_color
+        return logging.Formatter.format(self, record)
+
+
+class ConsoleHandler(logging.StreamHandler):
+
+    def filter(self, record):
+        try:
+            msg = record.msg
+            k = msg.split(':', 1)
+            if k[0] == 'stderr' and len(k) == 2:
+                previous_stderr.write(k[1] + '\n')
+                return False
+        except:
+            pass
+        return True
+
+
+class LogFile(object):
+
+    def __init__(self, channel, func):
+        self.buffer = ''
+        self.func = func
+        self.channel = channel
+        self.errors = ''
+
+    def write(self, s):
+        s = self.buffer + s
+        self.flush()
+        f = self.func
+        channel = self.channel
+        lines = s.split('\n')
+        for l in lines[:-1]:
+            f('%s: %s' % (channel, l))
+        self.buffer = lines[-1]
+
+    def flush(self):
+        return
+
+    def isatty(self):
+        return False
+
+
+def logger_config_update(section, key, value):
+    if LOG_LEVELS.get(value) is None:
+        raise AttributeError('Loglevel {0!r} doesn\'t exists'.format(value))
+    Logger.setLevel(level=LOG_LEVELS.get(value))
+
+
+#: Kivy default logger instance
+Logger = logging.getLogger('kivy')
+Logger.logfile_activated = None
+Logger.trace = partial(Logger.log, logging.TRACE)
+
+# set the Kivy logger as the default
+logging.root = Logger
+
+# add default kivy logger
+Logger.addHandler(LoggerHistory())
+file_log_handler = None
+if 'KIVY_NO_FILELOG' not in os.environ:
+    file_log_handler = FileHandler()
+    Logger.addHandler(file_log_handler)
+
+# Use the custom handler instead of streaming one.
+if 'KIVY_NO_CONSOLELOG' not in os.environ:
+    if hasattr(sys, '_kivy_logging_handler'):
+        Logger.addHandler(getattr(sys, '_kivy_logging_handler'))
+    else:
+        use_color = (
+            (
+                os.environ.get("WT_SESSION") or
+                os.environ.get("COLORTERM") == 'truecolor' or
+                os.environ.get('PYCHARM_HOSTED') == '1' or
+                os.environ.get('TERM') in (
+                    'rxvt',
+                    'rxvt-256color',
+                    'rxvt-unicode',
+                    'rxvt-unicode-256color',
+                    'xterm',
+                    'xterm-256color',
+                )
+            ) and os.environ.get('KIVY_BUILD') not in ('android', 'ios')
+        )
+        if not use_color:
+            # No additional control characters will be inserted inside the
+            # levelname field, 7 chars will fit "WARNING"
+            color_fmt = formatter_message(
+                '[%(levelname)-7s] %(message)s', use_color)
+        else:
+            # levelname field width need to take into account the length of the
+            # color control codes (7+4 chars for bold+color, and reset)
+            color_fmt = formatter_message(
+                '[%(levelname)-18s] %(message)s', use_color)
+        formatter = ColoredFormatter(color_fmt, use_color=use_color)
+        console = ConsoleHandler()
+        console.setFormatter(formatter)
+        Logger.addHandler(console)
+
+# install stderr handlers
+sys.stderr = LogFile('stderr', Logger.warning)
diff --git a/kivy/metrics.py b/kivy/metrics.py
new file mode 100644
index 0000000..63bc838
--- /dev/null
+++ b/kivy/metrics.py
@@ -0,0 +1,421 @@
+'''
+Metrics
+=======
+
+.. versionadded:: 1.5.0
+
+A screen is defined by its physical size, density and resolution. These
+factors are essential for creating UI's with correct size everywhere.
+
+In Kivy, all the graphics pipelines work with pixels. But using pixels as a
+measurement unit is problematic because sizes change according to the
+screen.
+
+Dimensions
+----------
+
+If you want to design your UI for different screen sizes, you will want better
+measurement units to work with. Kivy provides some more scalable alternatives.
+
+:Units:
+    `pt`
+        Points - 1/72 of an inch based on the physical size of the screen.
+        Prefer to use sp instead of pt.
+    `mm`
+        Millimeters - Based on the physical size of the screen.
+    `cm`
+        Centimeters - Based on the physical size of the screen.
+    `in`
+        Inches - Based on the physical size of the screen.
+    `dp`
+        Density-independent Pixels - An abstract unit that is based on the
+        physical density of the screen. With a :attr:`~MetricsBase.density` of
+        1, 1dp is equal to 1px. When running on a higher density screen, the
+        number of pixels used to draw 1dp is scaled up a factor appropriate to
+        the screen's dpi, and the inverse for a lower dpi.
+        The ratio of dp-to-pixels will change with the screen density, but not
+        necessarily in direct proportion. Using the dp unit is a simple
+        solution to making the view dimensions in your layout resize
+        properly for different screen densities. In others words, it
+        provides consistency for the real-world size of your UI across
+        different devices.
+    `sp`
+        Scale-independent Pixels - This is like the dp unit, but it is also
+        scaled by the user's font size preference. We recommend you use this
+        unit when specifying font sizes, so the font size will be adjusted to
+        both the screen density and the user's preference.
+
+Examples
+--------
+
+Here is an example of creating a label with a sp font_size and setting the
+height manually with a 10dp margin::
+
+    #:kivy 1.5.0
+    <MyWidget>:
+        Label:
+            text: 'Hello world'
+            font_size: '15sp'
+            size_hint_y: None
+            height: self.texture_size[1] + dp(10)
+
+Manual control of metrics
+-------------------------
+
+The metrics cannot be changed at runtime. Once a value has been converted to
+pixels, you can't retrieve the original value anymore. This stems from the fact
+that the DPI and density of a device cannot be changed at runtime.
+
+We provide some environment variables to control metrics:
+
+- `KIVY_METRICS_DENSITY`: if set, this value will be used for
+  :attr:`~MetricsBase.density` instead of the systems one. On android,
+  the value varies between 0.75, 1, 1.5 and 2.
+
+- `KIVY_METRICS_FONTSCALE`: if set, this value will be used for
+  :attr:`~MetricsBase.fontscale` instead of the systems one. On android, the
+  value varies between 0.8 and 1.2.
+
+- `KIVY_DPI`: if set, this value will be used for :attr:`~MetricsBase.dpi`.
+  Please
+  note that setting the DPI will not impact the dp/sp notation because these
+  are based on the screen density.
+
+For example, if you want to simulate a high-density screen (like the HTC One
+X)::
+
+    KIVY_DPI=320 KIVY_METRICS_DENSITY=2 python main.py --size 1280x720
+
+Or a medium-density (like Motorola Droid 2)::
+
+    KIVY_DPI=240 KIVY_METRICS_DENSITY=1.5 python main.py --size 854x480
+
+You can also simulate an alternative user preference for fontscale as follows::
+
+    KIVY_METRICS_FONTSCALE=1.2 python main.py
+
+'''
+
+
+from os import environ
+from kivy.utils import platform
+from kivy.properties import AliasProperty
+from kivy.event import EventDispatcher
+from kivy.setupconfig import USE_SDL2
+from kivy.context import register_context
+from kivy._metrics import dpi2px, NUMERIC_FORMATS, dispatch_pixel_scale, \
+    sync_pixel_scale
+
+
+__all__ = (
+    'Metrics', 'MetricsBase', 'pt', 'inch', 'cm', 'mm', 'dp', 'sp', 'dpi2px',
+    'NUMERIC_FORMATS')
+
+
+_default_dpi = None
+_default_density = None
+_default_fontscale = None
+if environ.get('KIVY_DOC_INCLUDE', None) == '1':
+    _default_dpi = 132.
+    _default_density = 1
+else:
+    _custom_dpi = environ.get('KIVY_DPI')
+    if _custom_dpi:
+        _default_dpi = float(_custom_dpi)
+
+    _custom_density = environ.get('KIVY_METRICS_DENSITY')
+    if _custom_density:
+        _default_density = float(_custom_density)
+
+    _custom_fontscale = environ.get('KIVY_METRICS_FONTSCALE')
+    if _custom_fontscale:
+        _default_fontscale = float(_custom_fontscale)
+
+
+def pt(value) -> float:
+    '''Convert from points to pixels
+    '''
+    return dpi2px(value, 'pt')
+
+
+def inch(value) -> float:
+    '''Convert from inches to pixels
+    '''
+    return dpi2px(value, 'in')
+
+
+def cm(value) -> float:
+    '''Convert from centimeters to pixels
+    '''
+    return dpi2px(value, 'cm')
+
+
+def mm(value) -> float:
+    '''Convert from millimeters to pixels
+    '''
+    return dpi2px(value, 'mm')
+
+
+def dp(value) -> float:
+    '''Convert from density-independent pixels to pixels
+    '''
+    return dpi2px(value, 'dp')
+
+
+def sp(value) -> float:
+    '''Convert from scale-independent pixels to pixels
+    '''
+    return dpi2px(value, 'sp')
+
+
+class MetricsBase(EventDispatcher):
+    '''Class that contains the default attributes for Metrics. Don't use this
+    class directly, but use the `Metrics` instance.
+    '''
+
+    _dpi = _default_dpi
+
+    _density = _default_density
+
+    _fontscale = _default_fontscale
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.fbind('dpi', dispatch_pixel_scale)
+        self.fbind('density', dispatch_pixel_scale)
+        self.fbind('fontscale', dispatch_pixel_scale)
+
+    def get_dpi(self, force_recompute=False):
+        if not force_recompute and self._dpi is not None:
+            return self._dpi
+
+        if platform == 'android':
+            if USE_SDL2:
+                import jnius
+                Hardware = jnius.autoclass('org.renpy.android.Hardware')
+                value = Hardware.getDPI()
+            else:
+                import android
+                value = android.get_dpi()
+        elif platform == 'ios':
+            import ios
+            value = ios.get_dpi()
+        else:
+            # for all other platforms..
+            from kivy.base import EventLoop
+            EventLoop.ensure_window()
+            value = EventLoop.window.dpi
+
+        # because dp prop binds to dpi etc. its getter will be executed
+        # before dispatch_pixel_scale bound to dpi was called, so we need to
+        # call this to make sure it's updated
+        sync_pixel_scale(dpi=value)
+        return value
+
+    def set_dpi(self, value):
+        self._dpi = value
+        sync_pixel_scale(dpi=value)
+        return True
+
+    dpi: float = AliasProperty(get_dpi, set_dpi, cache=True)
+    '''The DPI of the screen.
+
+    Depending on the platform, the DPI can be taken from the Window provider
+    (Desktop mainly) or from a platform-specific module (like android/ios).
+
+    :attr:`dpi` is a :class:`~kivy.properties.AliasProperty` and can be
+    set to change the value. But, the :attr:`density` is reloaded and reset if
+    we got it from the Window and the Window ``dpi`` changed.
+    '''
+
+    def get_dpi_rounded(self):
+        dpi = self.dpi
+        if dpi < 140:
+            return 120
+        elif dpi < 200:
+            return 160
+        elif dpi < 280:
+            return 240
+        return 320
+
+    dpi_rounded: int = AliasProperty(
+        get_dpi_rounded, None, bind=('dpi', ), cache=True)
+    '''Return the :attr:`dpi` of the screen, rounded to the nearest of 120,
+    160, 240 or 320.
+
+    :attr:`dpi_rounded` is a :class:`~kivy.properties.AliasProperty` and
+    updates when :attr:`dpi` changes.
+    '''
+
+    def get_density(self, force_recompute=False):
+        if not force_recompute and self._density is not None:
+            return self._density
+
+        value = 1.0
+        if platform == 'android':
+            import jnius
+            Hardware = jnius.autoclass('org.renpy.android.Hardware')
+            value = Hardware.metrics.scaledDensity
+        elif platform == 'ios':
+            import ios
+            value = ios.get_scale()
+        elif platform in ('macosx', 'win'):
+            value = self.dpi / 96.
+
+        sync_pixel_scale(density=value)
+        return value
+
+    def set_density(self, value):
+        self._density = value
+        sync_pixel_scale(density=value)
+        return True
+
+    density: float = AliasProperty(
+        get_density, set_density, bind=('dpi', ), cache=True)
+    '''The density of the screen.
+
+    This value is 1 by default on desktops but varies on android depending on
+    the screen.
+
+    :attr:`density` is a :class:`~kivy.properties.AliasProperty` and can be
+    set to change the value. But, the :attr:`density` is reloaded and reset if
+    we got it from the Window and the Window ``density`` changed.
+    '''
+
+    def get_fontscale(self, force_recompute=False):
+        if not force_recompute and self._fontscale is not None:
+            return self._fontscale
+
+        value = 1.0
+        if platform == 'android':
+            from jnius import autoclass
+            if USE_SDL2:
+                PythonActivity = autoclass('org.kivy.android.PythonActivity')
+            else:
+                PythonActivity = autoclass('org.renpy.android.PythonActivity')
+            config = PythonActivity.mActivity.getResources().getConfiguration()
+            value = config.fontScale
+
+        sync_pixel_scale(fontscale=value)
+        return value
+
+    def set_fontscale(self, value):
+        self._fontscale = value
+        sync_pixel_scale(fontscale=value)
+        return True
+
+    fontscale: float = AliasProperty(get_fontscale, set_fontscale, cache=True)
+    '''The fontscale user preference.
+
+    This value is 1 by default but can vary between 0.8 and 1.2.
+
+    :attr:`fontscale` is a :class:`~kivy.properties.AliasProperty` and can be
+    set to change the value.
+    '''
+
+    def get_in(self):
+        # we bind to all dpi, density, fontscale, even though not all may be
+        # used for a specific suffix, because we don't want to rely on the
+        # internal details of dpi2px. But it will be one of the three. But it's
+        # an issue, since it won't trigger the prop if the value doesn't change
+        return dpi2px(1, 'in')
+
+    inch: float = AliasProperty(
+        get_in, None, bind=('dpi', 'density', 'fontscale'), cache=True)
+    """The scaling factor that converts from inches to pixels.
+
+    :attr:`inch` is a :class:`~kivy.properties.AliasProperty` containing the
+    factor. E.g in KV: ``width: self.texture_size[0] + 10 * Metrics.inch`` will
+    update width when :attr:`inch` changes from a screen configuration change.
+    """
+
+    def get_dp(self):
+        return dpi2px(1, 'dp')
+
+    dp: float = AliasProperty(
+        get_dp, None, bind=('dpi', 'density', 'fontscale'), cache=True)
+    """The scaling factor that converts from density-independent pixels to
+    pixels.
+
+    :attr:`dp` is a :class:`~kivy.properties.AliasProperty` containing the
+    factor. E.g in KV: ``width: self.texture_size[0] + 10 * Metrics.dp`` will
+    update width when :attr:`dp` changes from a screen configuration change.
+    """
+
+    def get_sp(self):
+        return dpi2px(1, 'sp')
+
+    sp: float = AliasProperty(
+        get_sp, None, bind=('dpi', 'density', 'fontscale'), cache=True)
+    """The scaling factor that converts from scale-independent pixels to
+    pixels.
+
+    :attr:`sp` is a :class:`~kivy.properties.AliasProperty` containing the
+    factor. E.g in KV: ``width: self.texture_size[0] + 10 * Metrics.sp`` will
+    update width when :attr:`sp` changes from a screen configuration change.
+    """
+
+    def get_pt(self):
+        return dpi2px(1, 'pt')
+
+    pt: float = AliasProperty(
+        get_pt, None, bind=('dpi', 'density', 'fontscale'), cache=True)
+    """The scaling factor that converts from points to pixels.
+
+    :attr:`pt` is a :class:`~kivy.properties.AliasProperty` containing the
+    factor. E.g in KV: ``width: self.texture_size[0] + 10 * Metrics.pt`` will
+    update width when :attr:`pt` changes from a screen configuration change.
+    """
+
+    def get_cm(self):
+        return dpi2px(1, 'cm')
+
+    cm: float = AliasProperty(
+        get_cm, None, bind=('dpi', 'density', 'fontscale'), cache=True)
+    """The scaling factor that converts from centimeters to pixels.
+
+    :attr:`cm` is a :class:`~kivy.properties.AliasProperty` containing the
+    factor. E.g in KV: ``width: self.texture_size[0] + 10 * Metrics.cm`` will
+    update width when :attr:`cm` changes from a screen configuration change.
+    """
+
+    def get_mm(self):
+        return dpi2px(1, 'mm')
+
+    mm: float = AliasProperty(
+        get_mm, None, bind=('dpi', 'density', 'fontscale'), cache=True)
+    """The scaling factor that converts from millimeters to pixels.
+
+    :attr:`mm` is a :class:`~kivy.properties.AliasProperty` containing the
+    factor. E.g in KV: ``width: self.texture_size[0] + 10 * Metrics.mm`` will
+    update width when :attr:`mm` changes from a screen configuration change.
+    """
+
+    def reset_metrics(self):
+        """Resets the dpi/density/fontscale to the platform values, overwriting
+        any manually set values.
+        """
+        self.dpi = self.get_dpi(force_recompute=True)
+        self.density = self.get_density(force_recompute=True)
+        self.fontscale = self.get_fontscale(force_recompute=True)
+
+    def reset_dpi(self, *args):
+        """Resets the dpi (and possibly density) to the platform values,
+        overwriting any manually set values.
+        """
+        self.dpi = self.get_dpi(force_recompute=True)
+
+    def _set_cached_scaling(self):
+        dispatch_pixel_scale()
+
+
+Metrics: MetricsBase = register_context('Metrics', MetricsBase)
+"""The metrics object storing the window scaling factors.
+
+.. versionadded:: 1.7.0
+
+.. versionchanged:: 2.1.0
+
+     :attr:`Metrics` is now a Context registered variable (like e.g.
+     :attr:`~kivy.clock.Clock`).
+"""
diff --git a/kivy/modules/__init__.py b/kivy/modules/__init__.py
new file mode 100644
index 0000000..c7802ab
--- /dev/null
+++ b/kivy/modules/__init__.py
@@ -0,0 +1,300 @@
+'''
+Modules
+=======
+
+Modules are classes that can be loaded when a Kivy application is starting. The
+loading of modules is managed by the config file. Currently, we include:
+
+    * :class:`~kivy.modules.touchring`: Draw a circle around each touch.
+    * :class:`~kivy.modules.monitor`: Add a red topbar that indicates the FPS
+      and a small graph indicating input activity.
+    * :class:`~kivy.modules.keybinding`: Bind some keys to actions, such as a
+      screenshot.
+    * :class:`~kivy.modules.recorder`: Record and playback a sequence of
+      events.
+    * :class:`~kivy.modules.screen`: Emulate the characteristics (dpi/density/
+      resolution) of different screens.
+    * :class:`~kivy.modules.inspector`: Examines your widget hierarchy and
+      widget properties.
+    * :class:`~kivy.modules.webdebugger`: Realtime examination of your app
+      internals via a web browser.
+    * :class:`~kivy.modules.joycursor`: Navigate in your app with a joystick.
+    * :class:`~kivy.modules.showborder`: Show widget's border.
+
+Modules are automatically loaded from the Kivy path and User path:
+
+    * `PATH_TO_KIVY/kivy/modules`
+    * `HOME/.kivy/mods`
+
+Activating a module
+-------------------
+
+There are various ways in which you can activate a kivy module.
+
+Activate a module in the config
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To activate a module this way, you can edit your configuration file (in your
+`HOME/.kivy/config.ini`)::
+
+    [modules]
+    # uncomment to activate
+    touchring =
+    # monitor =
+    # keybinding =
+
+Only the name of the module followed by "=" is sufficient to activate the
+module.
+
+Activate a module in Python
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Before starting your application, preferably at the start of your import, you
+can do something like this::
+
+    import kivy
+    kivy.require('1.0.8')
+
+    # Activate the touchring module
+    from kivy.config import Config
+    Config.set('modules', 'touchring', '')
+
+Activate a module via the commandline
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When starting your application from the commandline, you can add a
+*-m <modulename>* to the arguments. For example::
+
+    python main.py -m webdebugger
+
+.. note::
+    Some modules, such as the screen, may require additional parameters. They
+    will, however, print these parameters to the console when launched without
+    them.
+
+
+Create your own module
+----------------------
+
+Create a file in your `HOME/.kivy/mods`, and create 2 functions::
+
+    def start(win, ctx):
+        pass
+
+    def stop(win, ctx):
+        pass
+
+Start/stop are functions that will be called for every window opened in
+Kivy. When you are starting a module, you can use these to store and
+manage the module state. Use the `ctx` variable as a dictionary. This
+context is unique for each instance/start() call of the module, and will
+be passed to stop() too.
+
+'''
+
+__all__ = ('Modules', )
+
+from kivy.config import Config
+from kivy.logger import Logger
+import kivy
+import importlib
+import os
+import sys
+
+
+class ModuleContext:
+    '''Context of a module
+
+    You can access to the config with self.config.
+    '''
+
+    def __init__(self):
+        self.config = {}
+
+    def __repr__(self):
+        return repr(self.config)
+
+
+class ModuleBase:
+    '''Handle Kivy modules. It will automatically load and instantiate the
+    module for the general window.'''
+
+    def __init__(self, **kwargs):
+        self.mods = {}
+        self.wins = []
+
+    def add_path(self, path):
+        '''Add a path to search for modules in'''
+        if not os.path.exists(path):
+            return
+        if path not in sys.path:
+            sys.path.append(path)
+        dirs = os.listdir(path)
+        for module in dirs:
+            name, ext = os.path.splitext(module)
+            # accept only python extensions
+            if ext not in ('.py', '.pyo', '.pyc') or name == '__init__':
+                continue
+            self.mods[name] = {
+                'name': name,
+                'activated': False,
+                'context': ModuleContext()}
+
+    def list(self):
+        '''Return the list of available modules'''
+        return self.mods
+
+    def import_module(self, name):
+        try:
+            modname = 'kivy.modules.{0}'.format(name)
+            module = importlib.__import__(name=modname)
+            module = sys.modules[modname]
+        except ImportError:
+            try:
+                module = importlib.__import__(name=name)
+                module = sys.modules[name]
+            except ImportError:
+                Logger.exception('Modules: unable to import <%s>' % name)
+                # protect against missing module dependency crash
+                self.mods[name]['module'] = None
+                return
+        # basic check on module
+        if not hasattr(module, 'start'):
+            Logger.warning('Modules: Module <%s> missing start() function' %
+                           name)
+            return
+        if not hasattr(module, 'stop'):
+            err = 'Modules: Module <%s> missing stop() function' % name
+            Logger.warning(err)
+            return
+        self.mods[name]['module'] = module
+
+    def activate_module(self, name, win):
+        '''Activate a module on a window'''
+        if name not in self.mods:
+            Logger.warning('Modules: Module <%s> not found' % name)
+            return
+
+        mod = self.mods[name]
+
+        # ensure the module has been configured
+        if 'module' not in mod:
+            self._configure_module(name)
+
+        pymod = mod['module']
+        if not mod['activated']:
+            context = mod['context']
+            msg = 'Modules: Start <{0}> with config {1}'.format(
+                  name, context)
+            Logger.debug(msg)
+            pymod.start(win, context)
+            mod['activated'] = True
+
+    def deactivate_module(self, name, win):
+        '''Deactivate a module from a window'''
+        if name not in self.mods:
+            Logger.warning('Modules: Module <%s> not found' % name)
+            return
+        if 'module' not in self.mods[name]:
+            return
+
+        module = self.mods[name]['module']
+        if self.mods[name]['activated']:
+            module.stop(win, self.mods[name]['context'])
+            self.mods[name]['activated'] = False
+
+    def register_window(self, win):
+        '''Add the window to the window list'''
+        if win not in self.wins:
+            self.wins.append(win)
+        self.update()
+
+    def unregister_window(self, win):
+        '''Remove the window from the window list'''
+        if win in self.wins:
+            self.wins.remove(win)
+        self.update()
+
+    def update(self):
+        '''Update the status of the module for each window'''
+        modules_to_activate = [x[0] for x in Config.items('modules')]
+        for win in self.wins:
+            for name in self.mods:
+                if name not in modules_to_activate:
+                    self.deactivate_module(name, win)
+            for name in modules_to_activate:
+                try:
+                    self.activate_module(name, win)
+                except:
+                    import traceback
+                    traceback.print_exc()
+                    raise
+
+    def configure(self):
+        '''(internal) Configure all the modules before using them.
+        '''
+        modules_to_configure = [x[0] for x in Config.items('modules')]
+        for name in modules_to_configure:
+            if name not in self.mods:
+                Logger.warning('Modules: Module <%s> not found' % name)
+                continue
+            self._configure_module(name)
+
+    def _configure_module(self, name):
+        if 'module' not in self.mods[name]:
+            try:
+                self.import_module(name)
+            except ImportError:
+                return
+
+        # convert configuration like:
+        # -m mjpegserver:port=8080,fps=8
+        # and pass it in context.config token
+        config = dict()
+
+        args = Config.get('modules', name)
+        if args != '':
+            values = Config.get('modules', name).split(',')
+            for value in values:
+                x = value.split('=', 1)
+                if len(x) == 1:
+                    config[x[0]] = True
+                else:
+                    config[x[0]] = x[1]
+
+        self.mods[name]['context'].config = config
+
+        # call configure if module have one
+        if hasattr(self.mods[name]['module'], 'configure'):
+            self.mods[name]['module'].configure(config)
+
+    def usage_list(self):
+        print('Available modules')
+        print('=================')
+        for module in sorted(self.list()):
+            if 'module' not in self.mods[module]:
+                self.import_module(module)
+
+            # ignore modules without docstring
+            if not self.mods[module]['module'].__doc__:
+                continue
+
+            text = self.mods[module]['module'].__doc__.strip("\n ")
+            text = text.split('\n')
+            # make sure we don't get IndexError along the way
+            # then pretty format the header
+            if len(text) > 2:
+                if text[1].startswith('='):
+                    # '\n%-12s: %s' -> 12 spaces + ": "
+                    text[1] = '=' * (14 + len(text[1]))
+            text = '\n'.join(text)
+            print('\n%-12s: %s' % (module, text))
+
+
+Modules = ModuleBase()
+Modules.add_path(kivy.kivy_modules_dir)
+if 'KIVY_DOC' not in os.environ:
+    Modules.add_path(kivy.kivy_usermodules_dir)
+
+if __name__ == '__main__':
+    print(Modules.list())
diff --git a/kivy/modules/__pycache__/__init__.cpython-310.pyc b/kivy/modules/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..489f9b1
Binary files /dev/null and b/kivy/modules/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/_webdebugger.cpython-310.pyc b/kivy/modules/__pycache__/_webdebugger.cpython-310.pyc
new file mode 100644
index 0000000..e1d9357
Binary files /dev/null and b/kivy/modules/__pycache__/_webdebugger.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/console.cpython-310.pyc b/kivy/modules/__pycache__/console.cpython-310.pyc
new file mode 100644
index 0000000..35fa07e
Binary files /dev/null and b/kivy/modules/__pycache__/console.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/cursor.cpython-310.pyc b/kivy/modules/__pycache__/cursor.cpython-310.pyc
new file mode 100644
index 0000000..9f8a396
Binary files /dev/null and b/kivy/modules/__pycache__/cursor.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/inspector.cpython-310.pyc b/kivy/modules/__pycache__/inspector.cpython-310.pyc
new file mode 100644
index 0000000..08cd45a
Binary files /dev/null and b/kivy/modules/__pycache__/inspector.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/joycursor.cpython-310.pyc b/kivy/modules/__pycache__/joycursor.cpython-310.pyc
new file mode 100644
index 0000000..b0d68f8
Binary files /dev/null and b/kivy/modules/__pycache__/joycursor.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/keybinding.cpython-310.pyc b/kivy/modules/__pycache__/keybinding.cpython-310.pyc
new file mode 100644
index 0000000..9e4aaac
Binary files /dev/null and b/kivy/modules/__pycache__/keybinding.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/monitor.cpython-310.pyc b/kivy/modules/__pycache__/monitor.cpython-310.pyc
new file mode 100644
index 0000000..4b62af6
Binary files /dev/null and b/kivy/modules/__pycache__/monitor.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/recorder.cpython-310.pyc b/kivy/modules/__pycache__/recorder.cpython-310.pyc
new file mode 100644
index 0000000..d903248
Binary files /dev/null and b/kivy/modules/__pycache__/recorder.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/screen.cpython-310.pyc b/kivy/modules/__pycache__/screen.cpython-310.pyc
new file mode 100644
index 0000000..85d9215
Binary files /dev/null and b/kivy/modules/__pycache__/screen.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/showborder.cpython-310.pyc b/kivy/modules/__pycache__/showborder.cpython-310.pyc
new file mode 100644
index 0000000..8fd303f
Binary files /dev/null and b/kivy/modules/__pycache__/showborder.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/touchring.cpython-310.pyc b/kivy/modules/__pycache__/touchring.cpython-310.pyc
new file mode 100644
index 0000000..2db1eb0
Binary files /dev/null and b/kivy/modules/__pycache__/touchring.cpython-310.pyc differ
diff --git a/kivy/modules/__pycache__/webdebugger.cpython-310.pyc b/kivy/modules/__pycache__/webdebugger.cpython-310.pyc
new file mode 100644
index 0000000..a706f56
Binary files /dev/null and b/kivy/modules/__pycache__/webdebugger.cpython-310.pyc differ
diff --git a/kivy/modules/_webdebugger.py b/kivy/modules/_webdebugger.py
new file mode 100644
index 0000000..35bcd43
--- /dev/null
+++ b/kivy/modules/_webdebugger.py
@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+# flake8: noqa
+
+import threading
+import json
+from gc import get_objects, garbage
+from kivy.clock import Clock
+from kivy.cache import Cache
+from collections import OrderedDict
+from kivy.logger import Logger
+
+try:
+    from flask import Flask, render_template_string, make_response
+except ImportError:
+    Logger.error('WebDebugger: unable to import Flask. Install it!')
+    raise
+
+history_max = 250
+
+
+class MissingOrderedDict(OrderedDict):
+
+    def __missing__(self, key):
+        self[key] = [0] * history_max
+        return self[key]
+
+
+metrics = MissingOrderedDict()
+app = Flask(__name__)
+
+
+@app.route('/')
+def index():
+    return render_template_string(html_index)
+
+
+@app.route('/metrics.json')
+def metrics_json():
+    resp = make_response(json.dumps(metrics), 200)
+    resp.headers['Content-Type'] = 'text/json'
+    return resp
+
+
+@app.route('/f/<name>')
+def getfile(name):
+    name = name.replace('.', '_')
+    text = globals()[name]
+    resp = make_response(text, 200)
+    if name.endswith('_js'):
+        resp.headers['Content-Type'] = 'text/javascript'
+    elif name.endswith('_jpg'):
+        resp.headers['Content-Type'] = 'image/jpeg'
+    return resp
+
+
+class FlaskThread(threading.Thread):
+
+    def run(self):
+        Clock.schedule_interval(self.dump_metrics, .1)
+        app.run(debug=True, use_debugger=True, use_reloader=False)
+
+    def dump_metrics(self, dt):
+        m = metrics
+        m['Python objects'].append(len(get_objects()))
+        m['Python garbage'].append(len(garbage))
+        m['FPS (internal)'].append(Clock.get_fps())
+        m['FPS (real)'].append(Clock.get_rfps())
+        m['Events'].append(len(Clock.get_events()))
+        for category in Cache._categories:
+            m['Cache ' + category].append(
+                len(Cache._objects.get(category, [])))
+        for values in m.values():
+            values.pop(0)
+            values[0] = 0
+
+
+def start(win, ctx):
+    ctx.thread = FlaskThread()
+    ctx.thread.daemon = True
+    ctx.thread.start()
+
+
+def stop(win, ctx):
+    pass
+
+# -----------------------------------------------------------------------------
+# DATA FILES
+# -----------------------------------------------------------------------------
+
+
+html_index = '''
+<html>
+<head>
+<title>Kivy - Web Debugger</title>
+<script type='text/javascript' src='/f/jquery.js'></script>
+<script type='text/javascript' src='/f/raphael.js'></script>
+<script type='text/javascript' src='/f/g_raphael.js'></script>
+<script type='text/javascript' src='/f/g_raphael_line.js'></script>
+<style type='text/css'>
+body {
+    font-family: Arial, Helvetica, sans-serif;
+    font-size: 13px;
+    color: #eee;
+    background: url('/f/background.jpg') repeat-x #718693;
+}
+
+.panel {
+    width: 400px;
+    float: left;
+    background-color: #BCCAD5;
+    margin: 0px 10px 10px 0px;
+    padding: 20px;
+    -moz-border-radius: 16px;
+    -webkit-border-radius: 16px;
+    border-radius: 16px;
+}
+
+.panel h2 {
+    margin: 0px;
+    padding: 0px 0px 10px 0px;
+    color: #516673;
+}
+
+</style>
+<script type='text/javascript'>
+
+var graphics = {};
+var rid = 0;
+var ids = {}
+
+function request_metrics() {
+    $.ajax({
+    url: '/metrics.json',
+    error: function(xhr, status) {
+        $('#error').html('Connection lost').show();
+        setTimeout('request_metrics()', 1000);
+    },
+    success: function(data) {
+        $('#error').hide();
+        for (var key in data) {
+            if ( typeof(graphics[key]) == 'undefined' ) {
+                rid += 1;
+                $('<div class="panel panel' + rid + '"><div id="r' + rid + '"></div></div>').appendTo($('#metrics'));
+                $('.panel' + rid).prepend(
+                    $('<h2 id="h' + rid + '"></h2>').html(key));
+                graphics[key] = Raphael('r' + rid, 400, 150);
+                ids[key] = rid;
+            }
+
+            var indices = [];
+            for (var i = 0; i < data[key].length; i++)
+                indices[i] = i;
+            var r = graphics[key];
+            $('#h'+ids[key]).html(key + ': ' + data[key][i-1]);
+            r.clear();
+            r.linechart(26, 0, 340, 150, indices, data[key], {
+                shade: true, axis: "0 1 0 1" });
+        }
+        setTimeout('request_metrics()', 250);
+    }
+    });
+}
+
+request_metrics();
+
+</script>
+</head>
+<body>
+<h1>Kivy - Web Debugger</h1>
+<div id='error'></div>
+
+<h2>Metrics</h2>
+<div id='metrics'>
+</div>
+</body>
+</html>
+'''
+
+jquery_js = r'''
+/*! jQuery v1.7.1 jquery.com | jquery.org/license */
+(function(a,b){function cy(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cv(a){if(!ck[a]){var b=c.body,d=f("<"+a+">").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){cl||(cl=c.createElement("iframe"),cl.frameBorder=cl.width=cl.height=0),b.appendChild(cl);if(!cm||!cl.createElement)cm=(cl.contentWindow||cl.contentDocument).document,cm.write((c.compatMode==="CSS1Compat"?"<!doctype html>":"")+"<html><body>"),cm.close();d=cm.createElement(a),cm.body.appendChild(d),e=f.css(d,"display"),b.removeChild(cl)}ck[a]=e}return ck[a]}function cu(a,b){var c={};f.each(cq.concat.apply([],cq.slice(0,b)),function(){c[this]=a});return c}function ct(){cr=b}function cs(){setTimeout(ct,0);return cr=f.now()}function cj(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function ci(){try{return new a.XMLHttpRequest}catch(b){}}function cc(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var d=a.dataTypes,e={},g,h,i=d.length,j,k=d[0],l,m,n,o,p;for(g=1;g<i;g++){if(g===1)for(h in a.converters)typeof h=="string"&&(e[h.toLowerCase()]=a.converters[h]);l=k,k=d[g];if(k==="*")k=l;else if(l!=="*"&&l!==k){m=l+" "+k,n=e[m]||e["* "+k];if(!n){p=b;for(o in e){j=o.split(" ");if(j[0]===l||j[0]==="*"){p=e[j[1]+" "+k];if(p){o=e[o],o===!0?n=p:p===!0&&(n=o);break}}}}!n&&!p&&f.error("No conversion from "+m.replace(" "," to ")),n!==!0&&(c=n?n(c):p(o(c)))}}return c}function cb(a,c,d){var e=a.contents,f=a.dataTypes,g=a.responseFields,h,i,j,k;for(i in g)i in d&&(c[g[i]]=d[i]);while(f[0]==="*")f.shift(),h===b&&(h=a.mimeType||c.getResponseHeader("content-type"));if(h)for(i in e)if(e[i]&&e[i].test(h)){f.unshift(i);break}if(f[0]in d)j=f[0];else{for(i in d){if(!f[0]||a.converters[i+" "+f[0]]){j=i;break}k||(k=i)}j=j||k}if(j){j!==f[0]&&f.unshift(j);return d[j]}}function ca(a,b,c,d){if(f.isArray(b))f.each(b,function(b,e){c||bE.test(a)?d(a,e):ca(a+"["+(typeof e=="object"||f.isArray(e)?b:"")+"]",e,c,d)});else if(!c&&b!=null&&typeof b=="object")for(var e in b)ca(a+"["+e+"]",b[e],c,d);else d(a,b)}function b_(a,c){var d,e,g=f.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((g[d]?a:e||(e={}))[d]=c[d]);e&&f.extend(!0,a,e)}function b$(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h=a[f],i=0,j=h?h.length:0,k=a===bT,l;for(;i<j&&(k||!l);i++)l=h[i](c,d,e),typeof l=="string"&&(!k||g[l]?l=b:(c.dataTypes.unshift(l),l=b$(a,c,d,e,l,g)));(k||!l)&&!g["*"]&&(l=b$(a,c,d,e,"*",g));return l}function bZ(a){return function(b,c){typeof b!="string"&&(c=b,b="*");if(f.isFunction(c)){var d=b.toLowerCase().split(bP),e=0,g=d.length,h,i,j;for(;e<g;e++)h=d[e],j=/^\+/.test(h),j&&(h=h.substr(1)||"*"),i=a[h]=a[h]||[],i[j?"unshift":"push"](c)}}}function bC(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=b==="width"?bx:by,g=0,h=e.length;if(d>0){if(c!=="border")for(;g<h;g++)c||(d-=parseFloat(f.css(a,"padding"+e[g]))||0),c==="margin"?d+=parseFloat(f.css(a,c+e[g]))||0:d-=parseFloat(f.css(a,"border"+e[g]+"Width"))||0;return d+"px"}d=bz(a,b,b);if(d<0||d==null)d=a.style[b]||0;d=parseFloat(d)||0;if(c)for(;g<h;g++)d+=parseFloat(f.css(a,"padding"+e[g]))||0,c!=="padding"&&(d+=parseFloat(f.css(a,"border"+e[g]+"Width"))||0),c==="margin"&&(d+=parseFloat(f.css(a,c+e[g]))||0);return d+"px"}function bp(a,b){b.src?f.ajax({url:b.src,async:!1,dataType:"script"}):f.globalEval((b.text||b.textContent||b.innerHTML||"").replace(bf,"/*$0*/")),b.parentNode&&b.parentNode.removeChild(b)}function bo(a){var b=c.createElement("div");bh.appendChild(b),b.innerHTML=a.outerHTML;return b.firstChild}function bn(a){var b=(a.nodeName||"").toLowerCase();b==="input"?bm(a):b!=="script"&&typeof a.getElementsByTagName!="undefined"&&f.grep(a.getElementsByTagName("input"),bm)}function bm(a){if(a.type==="checkbox"||a.type==="radio")a.defaultChecked=a.checked}function bl(a){return typeof a.getElementsByTagName!="undefined"?a.getElementsByTagName("*"):typeof a.querySelectorAll!="undefined"?a.querySelectorAll("*"):[]}function bk(a,b){var c;if(b.nodeType===1){b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase();if(c==="object")b.outerHTML=a.outerHTML;else if(c!=="input"||a.type!=="checkbox"&&a.type!=="radio"){if(c==="option")b.selected=a.defaultSelected;else if(c==="input"||c==="textarea")b.defaultValue=a.defaultValue}else a.checked&&(b.defaultChecked=b.checked=a.checked),b.value!==a.value&&(b.value=a.value);b.removeAttribute(f.expando)}}function bj(a,b){if(b.nodeType===1&&!!f.hasData(a)){var c,d,e,g=f._data(a),h=f._data(b,g),i=g.events;if(i){delete h.handle,h.events={};for(c in i)for(d=0,e=i[c].length;d<e;d++)f.event.add(b,c+(i[c][d].namespace?".":"")+i[c][d].namespace,i[c][d],i[c][d].data)}h.data&&(h.data=f.extend({},h.data))}}function bi(a,b){return f.nodeName(a,"table")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function U(a){var b=V.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}function T(a,b,c){b=b||0;if(f.isFunction(b))return f.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return f.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=f.grep(a,function(a){return a.nodeType===1});if(O.test(b))return f.filter(b,d,!c);b=f.filter(b,d)}return f.grep(a,function(a,d){return f.inArray(a,b)>=0===c})}function S(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function K(){return!0}function J(){return!1}function n(a,b,c){var d=b+"defer",e=b+"queue",g=b+"mark",h=f._data(a,d);h&&(c==="queue"||!f._data(a,e))&&(c==="mark"||!f._data(a,g))&&setTimeout(function(){!f._data(a,e)&&!f._data(a,g)&&(f.removeData(a,d,!0),h.fire())},0)}function m(a){for(var b in a){if(b==="data"&&f.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function l(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(k,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:f.isNumeric(d)?parseFloat(d):j.test(d)?f.parseJSON(d):d}catch(g){}f.data(a,c,d)}else d=b}return d}function h(a){var b=g[a]={},c,d;a=a.split(/\s+/);for(c=0,d=a.length;c<d;c++)b[a[c]]=!0;return b}var c=a.document,d=a.navigator,e=a.location,f=function(){function J(){if(!e.isReady){try{c.documentElement.doScroll("left")}catch(a){setTimeout(J,1);return}e.ready()}}var e=function(a,b){return new e.fn.init(a,b,h)},f=a.jQuery,g=a.$,h,i=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,j=/\S/,k=/^\s+/,l=/\s+$/,m=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,n=/^[\],:{}\s]*$/,o=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,p=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,q=/(?:^|:|,)(?:\s*\[)+/g,r=/(webkit)[ \/]([\w.]+)/,s=/(opera)(?:.*version)?[ \/]([\w.]+)/,t=/(msie) ([\w.]+)/,u=/(mozilla)(?:.*? rv:([\w.]+))?/,v=/-([a-z]|[0-9])/ig,w=/^-ms-/,x=function(a,b){return(b+"").toUpperCase()},y=d.userAgent,z,A,B,C=Object.prototype.toString,D=Object.prototype.hasOwnProperty,E=Array.prototype.push,F=Array.prototype.slice,G=String.prototype.trim,H=Array.prototype.indexOf,I={};e.fn=e.prototype={constructor:e,init:function(a,d,f){var g,h,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!d&&c.body){this.context=c,this[0]=c.body,this.selector=a,this.length=1;return this}if(typeof a=="string"){a.charAt(0)!=="<"||a.charAt(a.length-1)!==">"||a.length<3?g=i.exec(a):g=[null,a,null];if(g&&(g[1]||!d)){if(g[1]){d=d instanceof e?d[0]:d,k=d?d.ownerDocument||d:c,j=m.exec(a),j?e.isPlainObject(d)?(a=[c.createElement(j[1])],e.fn.attr.call(a,d,!0)):a=[k.createElement(j[1])]:(j=e.buildFragment([g[1]],[k]),a=(j.cacheable?e.clone(j.fragment):j.fragment).childNodes);return e.merge(this,a)}h=c.getElementById(g[2]);if(h&&h.parentNode){if(h.id!==g[2])return f.find(a);this.length=1,this[0]=h}this.context=c,this.selector=a;return this}return!d||d.jquery?(d||f).find(a):this.constructor(d).find(a)}if(e.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return e.makeArray(a,this)},selector:"",jquery:"1.7.1",length:0,size:function(){return this.length},toArray:function(){return F.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=this.constructor();e.isArray(a)?E.apply(d,a):e.merge(d,a),d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")");return d},each:function(a,b){return e.each(this,a,b)},ready:function(a){e.bindReady(),A.add(a);return this},eq:function(a){a=+a;return a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(F.apply(this,arguments),"slice",F.call(arguments).join(","))},map:function(a){return this.pushStack(e.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:E,sort:[].sort,splice:[].splice},e.fn.init.prototype=e.fn,e.extend=e.fn.extend=function(){var a,c,d,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i=="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!="object"&&!e.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j<k;j++)if((a=arguments[j])!=null)for(c in a){d=i[c],f=a[c];if(i===f)continue;l&&f&&(e.isPlainObject(f)||(g=e.isArray(f)))?(g?(g=!1,h=d&&e.isArray(d)?d:[]):h=d&&e.isPlainObject(d)?d:{},i[c]=e.extend(l,h,f)):f!==b&&(i[c]=f)}return i},e.extend({noConflict:function(b){a.$===e&&(a.$=g),b&&a.jQuery===e&&(a.jQuery=f);return e},isReady:!1,readyWait:1,holdReady:function(a){a?e.readyWait++:e.ready(!0)},ready:function(a){if(a===!0&&!--e.readyWait||a!==!0&&!e.isReady){if(!c.body)return setTimeout(e.ready,1);e.isReady=!0;if(a!==!0&&--e.readyWait>0)return;A.fireWith(c,[e]),e.fn.trigger&&e(c).trigger("ready").off("ready")}},bindReady:function(){if(!A){A=e.Callbacks("once memory");if(c.readyState==="complete")return setTimeout(e.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",B,!1),a.addEventListener("load",e.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",B),a.attachEvent("onload",e.ready);var b=!1;try{b=a.frameElement==null}catch(d){}c.documentElement.doScroll&&b&&J()}}},isFunction:function(a){return e.type(a)==="function"},isArray:Array.isArray||function(a){return e.type(a)==="array"},isWindow:function(a){return a&&typeof a=="object"&&"setInterval"in a},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):I[C.call(a)]||"object"},isPlainObject:function(a){if(!a||e.type(a)!=="object"||a.nodeType||e.isWindow(a))return!1;try{if(a.constructor&&!D.call(a,"constructor")&&!D.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||D.call(a,d)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw new Error(a)},parseJSON:function(b){if(typeof b!="string"||!b)return null;b=e.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(n.test(b.replace(o,"@").replace(p,"]").replace(q,"")))return(new Function("return "+b))();e.error("Invalid JSON: "+b)},parseXML:function(c){var d,f;try{a.DOMParser?(f=new DOMParser,d=f.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(g){d=b}(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&e.error("Invalid XML: "+c);return d},noop:function(){},globalEval:function(b){b&&j.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(w,"ms-").replace(v,x)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,d){var f,g=0,h=a.length,i=h===b||e.isFunction(a);if(d){if(i){for(f in a)if(c.apply(a[f],d)===!1)break}else for(;g<h;)if(c.apply(a[g++],d)===!1)break}else if(i){for(f in a)if(c.call(a[f],f,a[f])===!1)break}else for(;g<h;)if(c.call(a[g],g,a[g++])===!1)break;return a},trim:G?function(a){return a==null?"":G.call(a)}:function(a){return a==null?"":(a+"").replace(k,"").replace(l,"")},makeArray:function(a,b){var c=b||[];if(a!=null){var d=e.type(a);a.length==null||d==="string"||d==="function"||d==="regexp"||e.isWindow(a)?E.call(c,a):e.merge(c,a)}return c},inArray:function(a,b,c){var d;if(b){if(H)return H.call(b,a,c);d=b.length,c=c?c<0?Math.max(0,d+c):c:0;for(;c<d;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,c){var d=a.length,e=0;if(typeof c.length=="number")for(var f=c.length;e<f;e++)a[d++]=c[e];else while(c[e]!==b)a[d++]=c[e++];a.length=d;return a},grep:function(a,b,c){var d=[],e;c=!!c;for(var f=0,g=a.length;f<g;f++)e=!!b(a[f],f),c!==e&&d.push(a[f]);return d},map:function(a,c,d){var f,g,h=[],i=0,j=a.length,k=a instanceof e||j!==b&&typeof j=="number"&&(j>0&&a[0]&&a[j-1]||j===0||e.isArray(a));if(k)for(;i<j;i++)f=c(a[i],i,d),f!=null&&(h[h.length]=f);else for(g in a)f=c(a[g],g,d),f!=null&&(h[h.length]=f);return h.concat.apply([],h)},guid:1,proxy:function(a,c){if(typeof c=="string"){var d=a[c];c=a,a=d}if(!e.isFunction(a))return b;var f=F.call(arguments,2),g=function(){return a.apply(c,f.concat(F.call(arguments)))};g.guid=a.guid=a.guid||g.guid||e.guid++;return g},access:function(a,c,d,f,g,h){var i=a.length;if(typeof c=="object"){for(var j in c)e.access(a,j,c[j],f,g,d);return a}if(d!==b){f=!h&&f&&e.isFunction(d);for(var k=0;k<i;k++)g(a[k],c,f?d.call(a[k],k,g(a[k],c)):d,h);return a}return i?g(a[0],c):b},now:function(){return(new Date).getTime()},uaMatch:function(a){a=a.toLowerCase();var b=r.exec(a)||s.exec(a)||t.exec(a)||a.indexOf("compatible")<0&&u.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},sub:function(){function a(b,c){return new a.fn.init(b,c)}e.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function(d,f){f&&f instanceof e&&!(f instanceof a)&&(f=a(f));return e.fn.init.call(this,d,f,b)},a.fn.init.prototype=a.fn;var b=a(c);return a},browser:{}}),e.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){I["[object "+b+"]"]=b.toLowerCase()}),z=e.uaMatch(y),z.browser&&(e.browser[z.browser]=!0,e.browser.version=z.version),e.browser.webkit&&(e.browser.safari=!0),j.test(" ")&&(k=/^[\s\xA0]+/,l=/[\s\xA0]+$/),h=e(c),c.addEventListener?B=function(){c.removeEventListener("DOMContentLoaded",B,!1),e.ready()}:c.attachEvent&&(B=function(){c.readyState==="complete"&&(c.detachEvent("onreadystatechange",B),e.ready())});return e}(),g={};f.Callbacks=function(a){a=a?g[a]||h(a):{};var c=[],d=[],e,i,j,k,l,m=function(b){var d,e,g,h,i;for(d=0,e=b.length;d<e;d++)g=b[d],h=f.type(g),h==="array"?m(g):h==="function"&&(!a.unique||!o.has(g))&&c.push(g)},n=function(b,f){f=f||[],e=!a.memory||[b,f],i=!0,l=j||0,j=0,k=c.length;for(;c&&l<k;l++)if(c[l].apply(b,f)===!1&&a.stopOnFalse){e=!0;break}i=!1,c&&(a.once?e===!0?o.disable():c=[]:d&&d.length&&(e=d.shift(),o.fireWith(e[0],e[1])))},o={add:function(){if(c){var a=c.length;m(arguments),i?k=c.length:e&&e!==!0&&(j=a,n(e[0],e[1]))}return this},remove:function(){if(c){var b=arguments,d=0,e=b.length;for(;d<e;d++)for(var f=0;f<c.length;f++)if(b[d]===c[f]){i&&f<=k&&(k--,f<=l&&l--),c.splice(f--,1);if(a.unique)break}}return this},has:function(a){if(c){var b=0,d=c.length;for(;b<d;b++)if(a===c[b])return!0}return!1},empty:function(){c=[];return this},disable:function(){c=d=e=b;return this},disabled:function(){return!c},lock:function(){d=b,(!e||e===!0)&&o.disable();return this},locked:function(){return!d},fireWith:function(b,c){d&&(i?a.once||d.push([b,c]):(!a.once||!e)&&n(b,c));return this},fire:function(){o.fireWith(this,arguments);return this},fired:function(){return!!e}};return o};var i=[].slice;f.extend({Deferred:function(a){var b=f.Callbacks("once memory"),c=f.Callbacks("once memory"),d=f.Callbacks("memory"),e="pending",g={resolve:b,reject:c,notify:d},h={done:b.add,fail:c.add,progress:d.add,state:function(){return e},isResolved:b.fired,isRejected:c.fired,then:function(a,b,c){i.done(a).fail(b).progress(c);return this},always:function(){i.done.apply(i,arguments).fail.apply(i,arguments);return this},pipe:function(a,b,c){return f.Deferred(function(d){f.each({done:[a,"resolve"],fail:[b,"reject"],progress:[c,"notify"]},function(a,b){var c=b[0],e=b[1],g;f.isFunction(c)?i[a](function(){g=c.apply(this,arguments),g&&f.isFunction(g.promise)?g.promise().then(d.resolve,d.reject,d.notify):d[e+"With"](this===i?d:this,[g])}):i[a](d[e])})}).promise()},promise:function(a){if(a==null)a=h;else for(var b in h)a[b]=h[b];return a}},i=h.promise({}),j;for(j in g)i[j]=g[j].fire,i[j+"With"]=g[j].fireWith;i.done(function(){e="resolved"},c.disable,d.lock).fail(function(){e="rejected"},b.disable,d.lock),a&&a.call(i,i);return i},when:function(a){function m(a){return function(b){e[a]=arguments.length>1?i.call(arguments,0):b,j.notifyWith(k,e)}}function l(a){return function(c){b[a]=arguments.length>1?i.call(arguments,0):c,--g||j.resolveWith(j,b)}}var b=i.call(arguments,0),c=0,d=b.length,e=Array(d),g=d,h=d,j=d<=1&&a&&f.isFunction(a.promise)?a:f.Deferred(),k=j.promise();if(d>1){for(;c<d;c++)b[c]&&b[c].promise&&f.isFunction(b[c].promise)?b[c].promise().then(l(c),j.reject,m(c)):--g;g||j.resolveWith(j,b)}else j!==a&&j.resolveWith(j,d?[a]:[]);return k}}),f.support=function(){var b,d,e,g,h,i,j,k,l,m,n,o,p,q=c.createElement("div"),r=c.documentElement;q.setAttribute("className","t"),q.innerHTML="   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>",d=q.getElementsByTagName("*"),e=q.getElementsByTagName("a")[0];if(!d||!d.length||!e)return{};g=c.createElement("select"),h=g.appendChild(c.createElement("option")),i=q.getElementsByTagName("input")[0],b={leadingWhitespace:q.firstChild.nodeType===3,tbody:!q.getElementsByTagName("tbody").length,htmlSerialize:!!q.getElementsByTagName("link").length,style:/top/.test(e.getAttribute("style")),hrefNormalized:e.getAttribute("href")==="/a",opacity:/^0.55/.test(e.style.opacity),cssFloat:!!e.style.cssFloat,checkOn:i.value==="on",optSelected:h.selected,getSetAttribute:q.className!=="t",enctype:!!c.createElement("form").enctype,html5Clone:c.createElement("nav").cloneNode(!0).outerHTML!=="<:nav></:nav>",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0},i.checked=!0,b.noCloneChecked=i.cloneNode(!0).checked,g.disabled=!0,b.optDisabled=!h.disabled;try{delete q.test}catch(s){b.deleteExpando=!1}!q.addEventListener&&q.attachEvent&&q.fireEvent&&(q.attachEvent("onclick",function(){b.noCloneEvent=!1}),q.cloneNode(!0).fireEvent("onclick")),i=c.createElement("input"),i.value="t",i.setAttribute("type","radio"),b.radioValue=i.value==="t",i.setAttribute("checked","checked"),q.appendChild(i),k=c.createDocumentFragment(),k.appendChild(q.lastChild),b.checkClone=k.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=i.checked,k.removeChild(i),k.appendChild(q),q.innerHTML="",a.getComputedStyle&&(j=c.createElement("div"),j.style.width="0",j.style.marginRight="0",q.style.width="2px",q.appendChild(j),b.reliableMarginRight=(parseInt((a.getComputedStyle(j,null)||{marginRight:0}).marginRight,10)||0)===0);if(q.attachEvent)for(o in{submit:1,change:1,focusin:1})n="on"+o,p=n in q,p||(q.setAttribute(n,"return;"),p=typeof q[n]=="function"),b[o+"Bubbles"]=p;k.removeChild(q),k=g=h=j=q=i=null,f(function(){var a,d,e,g,h,i,j,k,m,n,o,r=c.getElementsByTagName("body")[0];!r||(j=1,k="position:absolute;top:0;left:0;width:1px;height:1px;margin:0;",m="visibility:hidden;border:0;",n="style='"+k+"border:5px solid #000;padding:0;'",o="<div "+n+"><div></div></div>"+"<table "+n+" cellpadding='0' cellspacing='0'>"+"<tr><td></td></tr></table>",a=c.createElement("div"),a.style.cssText=m+"width:0;height:0;position:static;top:0;margin-top:"+j+"px",r.insertBefore(a,r.firstChild),q=c.createElement("div"),a.appendChild(q),q.innerHTML="<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>",l=q.getElementsByTagName("td"),p=l[0].offsetHeight===0,l[0].style.display="",l[1].style.display="none",b.reliableHiddenOffsets=p&&l[0].offsetHeight===0,q.innerHTML="",q.style.width=q.style.paddingLeft="1px",f.boxModel=b.boxModel=q.offsetWidth===2,typeof q.style.zoom!="undefined"&&(q.style.display="inline",q.style.zoom=1,b.inlineBlockNeedsLayout=q.offsetWidth===2,q.style.display="",q.innerHTML="<div style='width:4px;'></div>",b.shrinkWrapBlocks=q.offsetWidth!==2),q.style.cssText=k+m,q.innerHTML=o,d=q.firstChild,e=d.firstChild,h=d.nextSibling.firstChild.firstChild,i={doesNotAddBorder:e.offsetTop!==5,doesAddBorderForTableAndCells:h.offsetTop===5},e.style.position="fixed",e.style.top="20px",i.fixedPosition=e.offsetTop===20||e.offsetTop===15,e.style.position=e.style.top="",d.style.overflow="hidden",d.style.position="relative",i.subtractsBorderForOverflowNotVisible=e.offsetTop===-5,i.doesNotIncludeMarginInBodyOffset=r.offsetTop!==j,r.removeChild(a),q=a=null,f.extend(b,i))});return b}();var j=/^(?:\{.*\}|\[.*\])$/,k=/([A-Z])/g;f.extend({cache:{},uuid:0,expando:"jQuery"+(f.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){a=a.nodeType?f.cache[a[f.expando]]:a[f.expando];return!!a&&!m(a)},data:function(a,c,d,e){if(!!f.acceptData(a)){var g,h,i,j=f.expando,k=typeof c=="string",l=a.nodeType,m=l?f.cache:a,n=l?a[j]:a[j]&&j,o=c==="events";if((!n||!m[n]||!o&&!e&&!m[n].data)&&k&&d===b)return;n||(l?a[j]=n=++f.uuid:n=j),m[n]||(m[n]={},l||(m[n].toJSON=f.noop));if(typeof c=="object"||typeof c=="function")e?m[n]=f.extend(m[n],c):m[n].data=f.extend(m[n].data,c);g=h=m[n],e||(h.data||(h.data={}),h=h.data),d!==b&&(h[f.camelCase(c)]=d);if(o&&!h[c])return g.events;k?(i=h[c],i==null&&(i=h[f.camelCase(c)])):i=h;return i}},removeData:function(a,b,c){if(!!f.acceptData(a)){var d,e,g,h=f.expando,i=a.nodeType,j=i?f.cache:a,k=i?a[h]:h;if(!j[k])return;if(b){d=c?j[k]:j[k].data;if(d){f.isArray(b)||(b in d?b=[b]:(b=f.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,g=b.length;e<g;e++)delete d[b[e]];if(!(c?m:f.isEmptyObject)(d))return}}if(!c){delete j[k].data;if(!m(j[k]))return}f.support.deleteExpando||!j.setInterval?delete j[k]:j[k]=null,i&&(f.support.deleteExpando?delete a[h]:a.removeAttribute?a.removeAttribute(h):a[h]=null)}},_data:function(a,b,c){return f.data(a,b,c,!0)},acceptData:function(a){if(a.nodeName){var b=f.noData[a.nodeName.toLowerCase()];if(b)return b!==!0&&a.getAttribute("classid")===b}return!0}}),f.fn.extend({data:function(a,c){var d,e,g,h=null;if(typeof a=="undefined"){if(this.length){h=f.data(this[0]);if(this[0].nodeType===1&&!f._data(this[0],"parsedAttrs")){e=this[0].attributes;for(var i=0,j=e.length;i<j;i++)g=e[i].name,g.indexOf("data-")===0&&(g=f.camelCase(g.substring(5)),l(this[0],g,h[g]));f._data(this[0],"parsedAttrs",!0)}}return h}if(typeof a=="object")return this.each(function(){f.data(this,a)});d=a.split("."),d[1]=d[1]?"."+d[1]:"";if(c===b){h=this.triggerHandler("getData"+d[1]+"!",[d[0]]),h===b&&this.length&&(h=f.data(this[0],a),h=l(this[0],a,h));return h===b&&d[1]?this.data(d[0]):h}return this.each(function(){var b=f(this),e=[d[0],c];b.triggerHandler("setData"+d[1]+"!",e),f.data(this,a,c),b.triggerHandler("changeData"+d[1]+"!",e)})},removeData:function(a){return this.each(function(){f.removeData(this,a)})}}),f.extend({_mark:function(a,b){a&&(b=(b||"fx")+"mark",f._data(a,b,(f._data(a,b)||0)+1))},_unmark:function(a,b,c){a!==!0&&(c=b,b=a,a=!1);if(b){c=c||"fx";var d=c+"mark",e=a?0:(f._data(b,d)||1)-1;e?f._data(b,d,e):(f.removeData(b,d,!0),n(b,c,"mark"))}},queue:function(a,b,c){var d;if(a){b=(b||"fx")+"queue",d=f._data(a,b),c&&(!d||f.isArray(c)?d=f._data(a,b,f.makeArray(c)):d.push(c));return d||[]}},dequeue:function(a,b){b=b||"fx";var c=f.queue(a,b),d=c.shift(),e={};d==="inprogress"&&(d=c.shift()),d&&(b==="fx"&&c.unshift("inprogress"),f._data(a,b+".run",e),d.call(a,function(){f.dequeue(a,b)},e)),c.length||(f.removeData(a,b+"queue "+b+".run",!0),n(a,b,"queue"))}}),f.fn.extend({queue:function(a,c){typeof a!="string"&&(c=a,a="fx");if(c===b)return f.queue(this[0],a);return this.each(function(){var b=f.queue(this,a,c);a==="fx"&&b[0]!=="inprogress"&&f.dequeue(this,a)})},dequeue:function(a){return this.each(function(){f.dequeue(this,a)})},delay:function(a,b){a=f.fx?f.fx.speeds[a]||a:a,b=b||"fx";return this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){function m(){--h||d.resolveWith(e,[e])}typeof a!="string"&&(c=a,a=b),a=a||"fx";var d=f.Deferred(),e=this,g=e.length,h=1,i=a+"defer",j=a+"queue",k=a+"mark",l;while(g--)if(l=f.data(e[g],i,b,!0)||(f.data(e[g],j,b,!0)||f.data(e[g],k,b,!0))&&f.data(e[g],i,f.Callbacks("once memory"),!0))h++,l.add(m);m();return d.promise()}});var o=/[\n\t\r]/g,p=/\s+/,q=/\r/g,r=/^(?:button|input)$/i,s=/^(?:button|input|object|select|textarea)$/i,t=/^a(?:rea)?$/i,u=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,v=f.support.getSetAttribute,w,x,y;f.fn.extend({attr:function(a,b){return f.access(this,a,b,!0,f.attr)},removeAttr:function(a){return this.each(function(){f.removeAttr(this,a)})},prop:function(a,b){return f.access(this,a,b,!0,f.prop)},removeProp:function(a){a=f.propFix[a]||a;return this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,g,h,i;if(f.isFunction(a))return this.each(function(b){f(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(p);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{g=" "+e.className+" ";for(h=0,i=b.length;h<i;h++)~g.indexOf(" "+b[h]+" ")||(g+=b[h]+" ");e.className=f.trim(g)}}}return this},removeClass:function(a){var c,d,e,g,h,i,j;if(f.isFunction(a))return this.each(function(b){f(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(p);for(d=0,e=this.length;d<e;d++){g=this[d];if(g.nodeType===1&&g.className)if(a){h=(" "+g.className+" ").replace(o," ");for(i=0,j=c.length;i<j;i++)h=h.replace(" "+c[i]+" "," ");g.className=f.trim(h)}else g.className=""}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";if(f.isFunction(a))return this.each(function(c){f(this).toggleClass(a.call(this,c,this.className,b),b)});return this.each(function(){if(c==="string"){var e,g=0,h=f(this),i=b,j=a.split(p);while(e=j[g++])i=d?i:!h.hasClass(e),h[i?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&f._data(this,"__className__",this.className),this.className=this.className||a===!1?"":f._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ",c=0,d=this.length;for(;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(o," ").indexOf(b)>-1)return!0;return!1},val:function(a){var c,d,e,g=this[0];{if(!!arguments.length){e=f.isFunction(a);return this.each(function(d){var g=f(this),h;if(this.nodeType===1){e?h=a.call(this,d,g.val()):h=a,h==null?h="":typeof h=="number"?h+="":f.isArray(h)&&(h=f.map(h,function(a){return a==null?"":a+""})),c=f.valHooks[this.nodeName.toLowerCase()]||f.valHooks[this.type];if(!c||!("set"in c)||c.set(this,h,"value")===b)this.value=h}})}if(g){c=f.valHooks[g.nodeName.toLowerCase()]||f.valHooks[g.type];if(c&&"get"in c&&(d=c.get(g,"value"))!==b)return d;d=g.value;return typeof d=="string"?d.replace(q,""):d==null?"":d}}}}),f.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,g=a.selectedIndex,h=[],i=a.options,j=a.type==="select-one";if(g<0)return null;c=j?g:0,d=j?g+1:i.length;for(;c<d;c++){e=i[c];if(e.selected&&(f.support.optDisabled?!e.disabled:e.getAttribute("disabled")===null)&&(!e.parentNode.disabled||!f.nodeName(e.parentNode,"optgroup"))){b=f(e).val();if(j)return b;h.push(b)}}if(j&&!h.length&&i.length)return f(i[g]).val();return h},set:function(a,b){var c=f.makeArray(b);f(a).find("option").each(function(){this.selected=f.inArray(f(this).val(),c)>=0}),c.length||(a.selectedIndex=-1);return c}}},attrFn:{val:!0,css:!0,html:!0,text:!0,data:!0,width:!0,height:!0,offset:!0},attr:function(a,c,d,e){var g,h,i,j=a.nodeType;if(!!a&&j!==3&&j!==8&&j!==2){if(e&&c in f.attrFn)return f(a)[c](d);if(typeof a.getAttribute=="undefined")return f.prop(a,c,d);i=j!==1||!f.isXMLDoc(a),i&&(c=c.toLowerCase(),h=f.attrHooks[c]||(u.test(c)?x:w));if(d!==b){if(d===null){f.removeAttr(a,c);return}if(h&&"set"in h&&i&&(g=h.set(a,d,c))!==b)return g;a.setAttribute(c,""+d);return d}if(h&&"get"in h&&i&&(g=h.get(a,c))!==null)return g;g=a.getAttribute(c);return g===null?b:g}},removeAttr:function(a,b){var c,d,e,g,h=0;if(b&&a.nodeType===1){d=b.toLowerCase().split(p),g=d.length;for(;h<g;h++)e=d[h],e&&(c=f.propFix[e]||e,f.attr(a,e,""),a.removeAttribute(v?e:c),u.test(e)&&c in a&&(a[c]=!1))}},attrHooks:{type:{set:function(a,b){if(r.test(a.nodeName)&&a.parentNode)f.error("type property can't be changed");else if(!f.support.radioValue&&b==="radio"&&f.nodeName(a,"input")){var c=a.value;a.setAttribute("type",b),c&&(a.value=c);return b}}},value:{get:function(a,b){if(w&&f.nodeName(a,"button"))return w.get(a,b);return b in a?a.value:null},set:function(a,b,c){if(w&&f.nodeName(a,"button"))return w.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e,g,h,i=a.nodeType;if(!!a&&i!==3&&i!==8&&i!==2){h=i!==1||!f.isXMLDoc(a),h&&(c=f.propFix[c]||c,g=f.propHooks[c]);return d!==b?g&&"set"in g&&(e=g.set(a,d,c))!==b?e:a[c]=d:g&&"get"in g&&(e=g.get(a,c))!==null?e:a[c]}},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):s.test(a.nodeName)||t.test(a.nodeName)&&a.href?0:b}}}}),f.attrHooks.tabindex=f.propHooks.tabIndex,x={get:function(a,c){var d,e=f.prop(a,c);return e===!0||typeof e!="boolean"&&(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;b===!1?f.removeAttr(a,c):(d=f.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase()));return c}},v||(y={name:!0,id:!0},w=f.valHooks.button={get:function(a,c){var d;d=a.getAttributeNode(c);return d&&(y[c]?d.nodeValue!=="":d.specified)?d.nodeValue:b},set:function(a,b,d){var e=a.getAttributeNode(d);e||(e=c.createAttribute(d),a.setAttributeNode(e));return e.nodeValue=b+""}},f.attrHooks.tabindex.set=w.set,f.each(["width","height"],function(a,b){f.attrHooks[b]=f.extend(f.attrHooks[b],{set:function(a,c){if(c===""){a.setAttribute(b,"auto");return c}}})}),f.attrHooks.contenteditable={get:w.get,set:function(a,b,c){b===""&&(b="false"),w.set(a,b,c)}}),f.support.hrefNormalized||f.each(["href","src","width","height"],function(a,c){f.attrHooks[c]=f.extend(f.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),f.support.style||(f.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=""+b}}),f.support.optSelected||(f.propHooks.selected=f.extend(f.propHooks.selected,{get:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex);return null}})),f.support.enctype||(f.propFix.enctype="encoding"),f.support.checkOn||f.each(["radio","checkbox"],function(){f.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),f.each(["radio","checkbox"],function(){f.valHooks[this]=f.extend(f.valHooks[this],{set:function(a,b){if(f.isArray(b))return a.checked=f.inArray(f(a).val(),b)>=0}})});var z=/^(?:textarea|input|select)$/i,A=/^([^\.]*)?(?:\.(.+))?$/,B=/\bhover(\.\S+)?\b/,C=/^key/,D=/^(?:mouse|contextmenu)|click/,E=/^(?:focusinfocus|focusoutblur)$/,F=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,G=function(a){var b=F.exec(a);b&&(b[1]=(b[1]||"").toLowerCase(),b[3]=b[3]&&new RegExp("(?:^|\\s)"+b[3]+"(?:\\s|$)"));return b},H=function(a,b){var c=a.attributes||{};return(!b[1]||a.nodeName.toLowerCase()===b[1])&&(!b[2]||(c.id||{}).value===b[2])&&(!b[3]||b[3].test((c["class"]||{}).value))},I=function(a){return f.event.special.hover?a:a.replace(B,"mouseenter$1 mouseleave$1")};
+f.event={add:function(a,c,d,e,g){var h,i,j,k,l,m,n,o,p,q,r,s;if(!(a.nodeType===3||a.nodeType===8||!c||!d||!(h=f._data(a)))){d.handler&&(p=d,d=p.handler),d.guid||(d.guid=f.guid++),j=h.events,j||(h.events=j={}),i=h.handle,i||(h.handle=i=function(a){return typeof f!="undefined"&&(!a||f.event.triggered!==a.type)?f.event.dispatch.apply(i.elem,arguments):b},i.elem=a),c=f.trim(I(c)).split(" ");for(k=0;k<c.length;k++){l=A.exec(c[k])||[],m=l[1],n=(l[2]||"").split(".").sort(),s=f.event.special[m]||{},m=(g?s.delegateType:s.bindType)||m,s=f.event.special[m]||{},o=f.extend({type:m,origType:l[1],data:e,handler:d,guid:d.guid,selector:g,quick:G(g),namespace:n.join(".")},p),r=j[m];if(!r){r=j[m]=[],r.delegateCount=0;if(!s.setup||s.setup.call(a,e,n,i)===!1)a.addEventListener?a.addEventListener(m,i,!1):a.attachEvent&&a.attachEvent("on"+m,i)}s.add&&(s.add.call(a,o),o.handler.guid||(o.handler.guid=d.guid)),g?r.splice(r.delegateCount++,0,o):r.push(o),f.event.global[m]=!0}a=null}},global:{},remove:function(a,b,c,d,e){var g=f.hasData(a)&&f._data(a),h,i,j,k,l,m,n,o,p,q,r,s;if(!!g&&!!(o=g.events)){b=f.trim(I(b||"")).split(" ");for(h=0;h<b.length;h++){i=A.exec(b[h])||[],j=k=i[1],l=i[2];if(!j){for(j in o)f.event.remove(a,j+b[h],c,d,!0);continue}p=f.event.special[j]||{},j=(d?p.delegateType:p.bindType)||j,r=o[j]||[],m=r.length,l=l?new RegExp("(^|\\.)"+l.split(".").sort().join("\\.(?:.*\\.)?")+"(\\.|$)"):null;for(n=0;n<r.length;n++)s=r[n],(e||k===s.origType)&&(!c||c.guid===s.guid)&&(!l||l.test(s.namespace))&&(!d||d===s.selector||d==="**"&&s.selector)&&(r.splice(n--,1),s.selector&&r.delegateCount--,p.remove&&p.remove.call(a,s));r.length===0&&m!==r.length&&((!p.teardown||p.teardown.call(a,l)===!1)&&f.removeEvent(a,j,g.handle),delete o[j])}f.isEmptyObject(o)&&(q=g.handle,q&&(q.elem=null),f.removeData(a,["events","handle"],!0))}},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,e,g){if(!e||e.nodeType!==3&&e.nodeType!==8){var h=c.type||c,i=[],j,k,l,m,n,o,p,q,r,s;if(E.test(h+f.event.triggered))return;h.indexOf("!")>=0&&(h=h.slice(0,-1),k=!0),h.indexOf(".")>=0&&(i=h.split("."),h=i.shift(),i.sort());if((!e||f.event.customEvent[h])&&!f.event.global[h])return;c=typeof c=="object"?c[f.expando]?c:new f.Event(h,c):new f.Event(h),c.type=h,c.isTrigger=!0,c.exclusive=k,c.namespace=i.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+i.join("\\.(?:.*\\.)?")+"(\\.|$)"):null,o=h.indexOf(":")<0?"on"+h:"";if(!e){j=f.cache;for(l in j)j[l].events&&j[l].events[h]&&f.event.trigger(c,d,j[l].handle.elem,!0);return}c.result=b,c.target||(c.target=e),d=d!=null?f.makeArray(d):[],d.unshift(c),p=f.event.special[h]||{};if(p.trigger&&p.trigger.apply(e,d)===!1)return;r=[[e,p.bindType||h]];if(!g&&!p.noBubble&&!f.isWindow(e)){s=p.delegateType||h,m=E.test(s+h)?e:e.parentNode,n=null;for(;m;m=m.parentNode)r.push([m,s]),n=m;n&&n===e.ownerDocument&&r.push([n.defaultView||n.parentWindow||a,s])}for(l=0;l<r.length&&!c.isPropagationStopped();l++)m=r[l][0],c.type=r[l][1],q=(f._data(m,"events")||{})[c.type]&&f._data(m,"handle"),q&&q.apply(m,d),q=o&&m[o],q&&f.acceptData(m)&&q.apply(m,d)===!1&&c.preventDefault();c.type=h,!g&&!c.isDefaultPrevented()&&(!p._default||p._default.apply(e.ownerDocument,d)===!1)&&(h!=="click"||!f.nodeName(e,"a"))&&f.acceptData(e)&&o&&e[h]&&(h!=="focus"&&h!=="blur"||c.target.offsetWidth!==0)&&!f.isWindow(e)&&(n=e[o],n&&(e[o]=null),f.event.triggered=h,e[h](),f.event.triggered=b,n&&(e[o]=n));return c.result}},dispatch:function(c){c=f.event.fix(c||a.event);var d=(f._data(this,"events")||{})[c.type]||[],e=d.delegateCount,g=[].slice.call(arguments,0),h=!c.exclusive&&!c.namespace,i=[],j,k,l,m,n,o,p,q,r,s,t;g[0]=c,c.delegateTarget=this;if(e&&!c.target.disabled&&(!c.button||c.type!=="click")){m=f(this),m.context=this.ownerDocument||this;for(l=c.target;l!=this;l=l.parentNode||this){o={},q=[],m[0]=l;for(j=0;j<e;j++)r=d[j],s=r.selector,o[s]===b&&(o[s]=r.quick?H(l,r.quick):m.is(s)),o[s]&&q.push(r);q.length&&i.push({elem:l,matches:q})}}d.length>e&&i.push({elem:this,matches:d.slice(e)});for(j=0;j<i.length&&!c.isPropagationStopped();j++){p=i[j],c.currentTarget=p.elem;for(k=0;k<p.matches.length&&!c.isImmediatePropagationStopped();k++){r=p.matches[k];if(h||!c.namespace&&!r.namespace||c.namespace_re&&c.namespace_re.test(r.namespace))c.data=r.data,c.handleObj=r,n=((f.event.special[r.origType]||{}).handle||r.handler).apply(p.elem,g),n!==b&&(c.result=n,n===!1&&(c.preventDefault(),c.stopPropagation()))}}return c.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){a.which==null&&(a.which=b.charCode!=null?b.charCode:b.keyCode);return a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,d){var e,f,g,h=d.button,i=d.fromElement;a.pageX==null&&d.clientX!=null&&(e=a.target.ownerDocument||c,f=e.documentElement,g=e.body,a.pageX=d.clientX+(f&&f.scrollLeft||g&&g.scrollLeft||0)-(f&&f.clientLeft||g&&g.clientLeft||0),a.pageY=d.clientY+(f&&f.scrollTop||g&&g.scrollTop||0)-(f&&f.clientTop||g&&g.clientTop||0)),!a.relatedTarget&&i&&(a.relatedTarget=i===a.target?d.toElement:i),!a.which&&h!==b&&(a.which=h&1?1:h&2?3:h&4?2:0);return a}},fix:function(a){if(a[f.expando])return a;var d,e,g=a,h=f.event.fixHooks[a.type]||{},i=h.props?this.props.concat(h.props):this.props;a=f.Event(g);for(d=i.length;d;)e=i[--d],a[e]=g[e];a.target||(a.target=g.srcElement||c),a.target.nodeType===3&&(a.target=a.target.parentNode),a.metaKey===b&&(a.metaKey=a.ctrlKey);return h.filter?h.filter(a,g):a},special:{ready:{setup:f.bindReady},load:{noBubble:!0},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(a,b,c){f.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}},simulate:function(a,b,c,d){var e=f.extend(new f.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?f.event.trigger(e,null,b):f.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},f.event.handle=f.event.dispatch,f.removeEvent=c.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){a.detachEvent&&a.detachEvent("on"+b,c)},f.Event=function(a,b){if(!(this instanceof f.Event))return new f.Event(a,b);a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?K:J):this.type=a,b&&f.extend(this,b),this.timeStamp=a&&a.timeStamp||f.now(),this[f.expando]=!0},f.Event.prototype={preventDefault:function(){this.isDefaultPrevented=K;var a=this.originalEvent;!a||(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){this.isPropagationStopped=K;var a=this.originalEvent;!a||(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=K,this.stopPropagation()},isDefaultPrevented:J,isPropagationStopped:J,isImmediatePropagationStopped:J},f.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){f.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c=this,d=a.relatedTarget,e=a.handleObj,g=e.selector,h;if(!d||d!==c&&!f.contains(c,d))a.type=e.origType,h=e.handler.apply(this,arguments),a.type=b;return h}}}),f.support.submitBubbles||(f.event.special.submit={setup:function(){if(f.nodeName(this,"form"))return!1;f.event.add(this,"click._submit keypress._submit",function(a){var c=a.target,d=f.nodeName(c,"input")||f.nodeName(c,"button")?c.form:b;d&&!d._submit_attached&&(f.event.add(d,"submit._submit",function(a){this.parentNode&&!a.isTrigger&&f.event.simulate("submit",this.parentNode,a,!0)}),d._submit_attached=!0)})},teardown:function(){if(f.nodeName(this,"form"))return!1;f.event.remove(this,"._submit")}}),f.support.changeBubbles||(f.event.special.change={setup:function(){if(z.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")f.event.add(this,"propertychange._change",function(a){a.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),f.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1,f.event.simulate("change",this,a,!0))});return!1}f.event.add(this,"beforeactivate._change",function(a){var b=a.target;z.test(b.nodeName)&&!b._change_attached&&(f.event.add(b,"change._change",function(a){this.parentNode&&!a.isSimulated&&!a.isTrigger&&f.event.simulate("change",this.parentNode,a,!0)}),b._change_attached=!0)})},handle:function(a){var b=a.target;if(this!==b||a.isSimulated||a.isTrigger||b.type!=="radio"&&b.type!=="checkbox")return a.handleObj.handler.apply(this,arguments)},teardown:function(){f.event.remove(this,"._change");return z.test(this.nodeName)}}),f.support.focusinBubbles||f.each({focus:"focusin",blur:"focusout"},function(a,b){var d=0,e=function(a){f.event.simulate(b,a.target,f.event.fix(a),!0)};f.event.special[b]={setup:function(){d++===0&&c.addEventListener(a,e,!0)},teardown:function(){--d===0&&c.removeEventListener(a,e,!0)}}}),f.fn.extend({on:function(a,c,d,e,g){var h,i;if(typeof a=="object"){typeof c!="string"&&(d=c,c=b);for(i in a)this.on(i,c,d,a[i],g);return this}d==null&&e==null?(e=c,d=c=b):e==null&&(typeof c=="string"?(e=d,d=b):(e=d,d=c,c=b));if(e===!1)e=J;else if(!e)return this;g===1&&(h=e,e=function(a){f().off(a);return h.apply(this,arguments)},e.guid=h.guid||(h.guid=f.guid++));return this.each(function(){f.event.add(this,a,e,d,c)})},one:function(a,b,c,d){return this.on.call(this,a,b,c,d,1)},off:function(a,c,d){if(a&&a.preventDefault&&a.handleObj){var e=a.handleObj;f(a.delegateTarget).off(e.namespace?e.type+"."+e.namespace:e.type,e.selector,e.handler);return this}if(typeof a=="object"){for(var g in a)this.off(g,c,a[g]);return this}if(c===!1||typeof c=="function")d=c,c=b;d===!1&&(d=J);return this.each(function(){f.event.remove(this,a,d,c)})},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},live:function(a,b,c){f(this.context).on(a,this.selector,b,c);return this},die:function(a,b){f(this.context).off(a,this.selector||"**",b);return this},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return arguments.length==1?this.off(a,"**"):this.off(b,a,c)},trigger:function(a,b){return this.each(function(){f.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return f.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||f.guid++,d=0,e=function(c){var e=(f._data(this,"lastToggle"+a.guid)||0)%d;f._data(this,"lastToggle"+a.guid,e+1),c.preventDefault();return b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),f.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){f.fn[b]=function(a,c){c==null&&(c=a,a=null);return arguments.length>0?this.on(b,null,a,c):this.trigger(b)},f.attrFn&&(f.attrFn[b]=!0),C.test(b)&&(f.event.fixHooks[b]=f.event.keyHooks),D.test(b)&&(f.event.fixHooks[b]=f.event.mouseHooks)}),function(){function x(a,b,c,e,f,g){for(var h=0,i=e.length;h<i;h++){var j=e[h];if(j){var k=!1;j=j[a];while(j){if(j[d]===c){k=e[j.sizset];break}if(j.nodeType===1){g||(j[d]=c,j.sizset=h);if(typeof b!="string"){if(j===b){k=!0;break}}else if(m.filter(b,[j]).length>0){k=j;break}}j=j[a]}e[h]=k}}}function w(a,b,c,e,f,g){for(var h=0,i=e.length;h<i;h++){var j=e[h];if(j){var k=!1;j=j[a];while(j){if(j[d]===c){k=e[j.sizset];break}j.nodeType===1&&!g&&(j[d]=c,j.sizset=h);if(j.nodeName.toLowerCase()===b){k=j;break}j=j[a]}e[h]=k}}}var a=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,d="sizcache"+(Math.random()+"").replace(".",""),e=0,g=Object.prototype.toString,h=!1,i=!0,j=/\\/g,k=/\r\n/g,l=/\W/;[0,0].sort(function(){i=!1;return 0});var m=function(b,d,e,f){e=e||[],d=d||c;var h=d;if(d.nodeType!==1&&d.nodeType!==9)return[];if(!b||typeof b!="string")return e;var i,j,k,l,n,q,r,t,u=!0,v=m.isXML(d),w=[],x=b;do{a.exec(""),i=a.exec(x);if(i){x=i[3],w.push(i[1]);if(i[2]){l=i[3];break}}}while(i);if(w.length>1&&p.exec(b))if(w.length===2&&o.relative[w[0]])j=y(w[0]+w[1],d,f);else{j=o.relative[w[0]]?[d]:m(w.shift(),d);while(w.length)b=w.shift(),o.relative[b]&&(b+=w.shift()),j=y(b,j,f)}else{!f&&w.length>1&&d.nodeType===9&&!v&&o.match.ID.test(w[0])&&!o.match.ID.test(w[w.length-1])&&(n=m.find(w.shift(),d,v),d=n.expr?m.filter(n.expr,n.set)[0]:n.set[0]);if(d){n=f?{expr:w.pop(),set:s(f)}:m.find(w.pop(),w.length===1&&(w[0]==="~"||w[0]==="+")&&d.parentNode?d.parentNode:d,v),j=n.expr?m.filter(n.expr,n.set):n.set,w.length>0?k=s(j):u=!1;while(w.length)q=w.pop(),r=q,o.relative[q]?r=w.pop():q="",r==null&&(r=d),o.relative[q](k,r,v)}else k=w=[]}k||(k=j),k||m.error(q||b);if(g.call(k)==="[object Array]")if(!u)e.push.apply(e,k);else if(d&&d.nodeType===1)for(t=0;k[t]!=null;t++)k[t]&&(k[t]===!0||k[t].nodeType===1&&m.contains(d,k[t]))&&e.push(j[t]);else for(t=0;k[t]!=null;t++)k[t]&&k[t].nodeType===1&&e.push(j[t]);else s(k,e);l&&(m(l,h,e,f),m.uniqueSort(e));return e};m.uniqueSort=function(a){if(u){h=i,a.sort(u);if(h)for(var b=1;b<a.length;b++)a[b]===a[b-1]&&a.splice(b--,1)}return a},m.matches=function(a,b){return m(a,null,null,b)},m.matchesSelector=function(a,b){return m(b,null,null,[a]).length>0},m.find=function(a,b,c){var d,e,f,g,h,i;if(!a)return[];for(e=0,f=o.order.length;e<f;e++){h=o.order[e];if(g=o.leftMatch[h].exec(a)){i=g[1],g.splice(1,1);if(i.substr(i.length-1)!=="\\"){g[1]=(g[1]||"").replace(j,""),d=o.find[h](g,b,c);if(d!=null){a=a.replace(o.match[h],"");break}}}}d||(d=typeof b.getElementsByTagName!="undefined"?b.getElementsByTagName("*"):[]);return{set:d,expr:a}},m.filter=function(a,c,d,e){var f,g,h,i,j,k,l,n,p,q=a,r=[],s=c,t=c&&c[0]&&m.isXML(c[0]);while(a&&c.length){for(h in o.filter)if((f=o.leftMatch[h].exec(a))!=null&&f[2]){k=o.filter[h],l=f[1],g=!1,f.splice(1,1);if(l.substr(l.length-1)==="\\")continue;s===r&&(r=[]);if(o.preFilter[h]){f=o.preFilter[h](f,s,d,r,e,t);if(!f)g=i=!0;else if(f===!0)continue}if(f)for(n=0;(j=s[n])!=null;n++)j&&(i=k(j,f,n,s),p=e^i,d&&i!=null?p?g=!0:s[n]=!1:p&&(r.push(j),g=!0));if(i!==b){d||(s=r),a=a.replace(o.match[h],"");if(!g)return[];break}}if(a===q)if(g==null)m.error(a);else break;q=a}return s},m.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)};var n=m.getText=function(a){var b,c,d=a.nodeType,e="";if(d){if(d===1||d===9){if(typeof a.textContent=="string")return a.textContent;if(typeof a.innerText=="string")return a.innerText.replace(k,"");for(a=a.firstChild;a;a=a.nextSibling)e+=n(a)}else if(d===3||d===4)return a.nodeValue}else for(b=0;c=a[b];b++)c.nodeType!==8&&(e+=n(c));return e},o=m.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,CLASS:/\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(a){return a.getAttribute("href")},type:function(a){return a.getAttribute("type")}},relative:{"+":function(a,b){var c=typeof b=="string",d=c&&!l.test(b),e=c&&!d;d&&(b=b.toLowerCase());for(var f=0,g=a.length,h;f<g;f++)if(h=a[f]){while((h=h.previousSibling)&&h.nodeType!==1);a[f]=e||h&&h.nodeName.toLowerCase()===b?h||!1:h===b}e&&m.filter(b,a,!0)},">":function(a,b){var c,d=typeof b=="string",e=0,f=a.length;if(d&&!l.test(b)){b=b.toLowerCase();for(;e<f;e++){c=a[e];if(c){var g=c.parentNode;a[e]=g.nodeName.toLowerCase()===b?g:!1}}}else{for(;e<f;e++)c=a[e],c&&(a[e]=d?c.parentNode:c.parentNode===b);d&&m.filter(b,a,!0)}},"":function(a,b,c){var d,f=e++,g=x;typeof b=="string"&&!l.test(b)&&(b=b.toLowerCase(),d=b,g=w),g("parentNode",b,f,a,d,c)},"~":function(a,b,c){var d,f=e++,g=x;typeof b=="string"&&!l.test(b)&&(b=b.toLowerCase(),d=b,g=w),g("previousSibling",b,f,a,d,c)}},find:{ID:function(a,b,c){if(typeof b.getElementById!="undefined"&&!c){var d=b.getElementById(a[1]);return d&&d.parentNode?[d]:[]}},NAME:function(a,b){if(typeof b.getElementsByName!="undefined"){var c=[],d=b.getElementsByName(a[1]);for(var e=0,f=d.length;e<f;e++)d[e].getAttribute("name")===a[1]&&c.push(d[e]);return c.length===0?null:c}},TAG:function(a,b){if(typeof b.getElementsByTagName!="undefined")return b.getElementsByTagName(a[1])}},preFilter:{CLASS:function(a,b,c,d,e,f){a=" "+a[1].replace(j,"")+" ";if(f)return a;for(var g=0,h;(h=b[g])!=null;g++)h&&(e^(h.className&&(" "+h.className+" ").replace(/[\t\n\r]/g," ").indexOf(a)>=0)?c||d.push(h):c&&(b[g]=!1));return!1},ID:function(a){return a[1].replace(j,"")},TAG:function(a,b){return a[1].replace(j,"").toLowerCase()},CHILD:function(a){if(a[1]==="nth"){a[2]||m.error(a[0]),a[2]=a[2].replace(/^\+|\s*/g,"");var b=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(a[2]==="even"&&"2n"||a[2]==="odd"&&"2n+1"||!/\D/.test(a[2])&&"0n+"+a[2]||a[2]);a[2]=b[1]+(b[2]||1)-0,a[3]=b[3]-0}else a[2]&&m.error(a[0]);a[0]=e++;return a},ATTR:function(a,b,c,d,e,f){var g=a[1]=a[1].replace(j,"");!f&&o.attrMap[g]&&(a[1]=o.attrMap[g]),a[4]=(a[4]||a[5]||"").replace(j,""),a[2]==="~="&&(a[4]=" "+a[4]+" ");return a},PSEUDO:function(b,c,d,e,f){if(b[1]==="not")if((a.exec(b[3])||"").length>1||/^\w/.test(b[3]))b[3]=m(b[3],null,null,c);else{var g=m.filter(b[3],c,d,!0^f);d||e.push.apply(e,g);return!1}else if(o.match.POS.test(b[0])||o.match.CHILD.test(b[0]))return!0;return b},POS:function(a){a.unshift(!0);return a}},filters:{enabled:function(a){return a.disabled===!1&&a.type!=="hidden"},disabled:function(a){return a.disabled===!0},checked:function(a){return a.checked===!0},selected:function(a){a.parentNode&&a.parentNode.selectedIndex;return a.selected===!0},parent:function(a){return!!a.firstChild},empty:function(a){return!a.firstChild},has:function(a,b,c){return!!m(c[3],a).length},header:function(a){return/h\d/i.test(a.nodeName)},text:function(a){var b=a.getAttribute("type"),c=a.type;return a.nodeName.toLowerCase()==="input"&&"text"===c&&(b===c||b===null)},radio:function(a){return a.nodeName.toLowerCase()==="input"&&"radio"===a.type},checkbox:function(a){return a.nodeName.toLowerCase()==="input"&&"checkbox"===a.type},file:function(a){return a.nodeName.toLowerCase()==="input"&&"file"===a.type},password:function(a){return a.nodeName.toLowerCase()==="input"&&"password"===a.type},submit:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"submit"===a.type},image:function(a){return a.nodeName.toLowerCase()==="input"&&"image"===a.type},reset:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"reset"===a.type},button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&"button"===a.type||b==="button"},input:function(a){return/input|select|textarea|button/i.test(a.nodeName)},focus:function(a){return a===a.ownerDocument.activeElement}},setFilters:{first:function(a,b){return b===0},last:function(a,b,c,d){return b===d.length-1},even:function(a,b){return b%2===0},odd:function(a,b){return b%2===1},lt:function(a,b,c){return b<c[3]-0},gt:function(a,b,c){return b>c[3]-0},nth:function(a,b,c){return c[3]-0===b},eq:function(a,b,c){return c[3]-0===b}},filter:{PSEUDO:function(a,b,c,d){var e=b[1],f=o.filters[e];if(f)return f(a,c,b,d);if(e==="contains")return(a.textContent||a.innerText||n([a])||"").indexOf(b[3])>=0;if(e==="not"){var g=b[3];for(var h=0,i=g.length;h<i;h++)if(g[h]===a)return!1;return!0}m.error(e)},CHILD:function(a,b){var c,e,f,g,h,i,j,k=b[1],l=a;switch(k){case"only":case"first":while(l=l.previousSibling)if(l.nodeType===1)return!1;if(k==="first")return!0;l=a;case"last":while(l=l.nextSibling)if(l.nodeType===1)return!1;return!0;case"nth":c=b[2],e=b[3];if(c===1&&e===0)return!0;f=b[0],g=a.parentNode;if(g&&(g[d]!==f||!a.nodeIndex)){i=0;for(l=g.firstChild;l;l=l.nextSibling)l.nodeType===1&&(l.nodeIndex=++i);g[d]=f}j=a.nodeIndex-e;return c===0?j===0:j%c===0&&j/c>=0}},ID:function(a,b){return a.nodeType===1&&a.getAttribute("id")===b},TAG:function(a,b){return b==="*"&&a.nodeType===1||!!a.nodeName&&a.nodeName.toLowerCase()===b},CLASS:function(a,b){return(" "+(a.className||a.getAttribute("class"))+" ").indexOf(b)>-1},ATTR:function(a,b){var c=b[1],d=m.attr?m.attr(a,c):o.attrHandle[c]?o.attrHandle[c](a):a[c]!=null?a[c]:a.getAttribute(c),e=d+"",f=b[2],g=b[4];return d==null?f==="!=":!f&&m.attr?d!=null:f==="="?e===g:f==="*="?e.indexOf(g)>=0:f==="~="?(" "+e+" ").indexOf(g)>=0:g?f==="!="?e!==g:f==="^="?e.indexOf(g)===0:f==="$="?e.substr(e.length-g.length)===g:f==="|="?e===g||e.substr(0,g.length+1)===g+"-":!1:e&&d!==!1},POS:function(a,b,c,d){var e=b[2],f=o.setFilters[e];if(f)return f(a,c,b,d)}}},p=o.match.POS,q=function(a,b){return"\\"+(b-0+1)};for(var r in o.match)o.match[r]=new RegExp(o.match[r].source+/(?![^\[]*\])(?![^\(]*\))/.source),o.leftMatch[r]=new RegExp(/(^(?:.|\r|\n)*?)/.source+o.match[r].source.replace(/\\(\d+)/g,q));var s=function(a,b){a=Array.prototype.slice.call(a,0);if(b){b.push.apply(b,a);return b}return a};try{Array.prototype.slice.call(c.documentElement.childNodes,0)[0].nodeType}catch(t){s=function(a,b){var c=0,d=b||[];if(g.call(a)==="[object Array]")Array.prototype.push.apply(d,a);else if(typeof a.length=="number")for(var e=a.length;c<e;c++)d.push(a[c]);else for(;a[c];c++)d.push(a[c]);return d}}var u,v;c.documentElement.compareDocumentPosition?u=function(a,b){if(a===b){h=!0;return 0}if(!a.compareDocumentPosition||!b.compareDocumentPosition)return a.compareDocumentPosition?-1:1;return a.compareDocumentPosition(b)&4?-1:1}:(u=function(a,b){if(a===b){h=!0;return 0}if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],g=a.parentNode,i=b.parentNode,j=g;if(g===i)return v(a,b);if(!g)return-1;if(!i)return 1;while(j)e.unshift(j),j=j.parentNode;j=i;while(j)f.unshift(j),j=j.parentNode;c=e.length,d=f.length;for(var k=0;k<c&&k<d;k++)if(e[k]!==f[k])return v(e[k],f[k]);return k===c?v(a,f[k],-1):v(e[k],b,1)},v=function(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}),function(){var a=c.createElement("div"),d="script"+(new Date).getTime(),e=c.documentElement;a.innerHTML="<a name='"+d+"'/>",e.insertBefore(a,e.firstChild),c.getElementById(d)&&(o.find.ID=function(a,c,d){if(typeof c.getElementById!="undefined"&&!d){var e=c.getElementById(a[1]);return e?e.id===a[1]||typeof e.getAttributeNode!="undefined"&&e.getAttributeNode("id").nodeValue===a[1]?[e]:b:[]}},o.filter.ID=function(a,b){var c=typeof a.getAttributeNode!="undefined"&&a.getAttributeNode("id");return a.nodeType===1&&c&&c.nodeValue===b}),e.removeChild(a),e=a=null}(),function(){var a=c.createElement("div");a.appendChild(c.createComment("")),a.getElementsByTagName("*").length>0&&(o.find.TAG=function(a,b){var c=b.getElementsByTagName(a[1]);if(a[1]==="*"){var d=[];for(var e=0;c[e];e++)c[e].nodeType===1&&d.push(c[e]);c=d}return c}),a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!="undefined"&&a.firstChild.getAttribute("href")!=="#"&&(o.attrHandle.href=function(a){return a.getAttribute("href",2)}),a=null}(),c.querySelectorAll&&function(){var a=m,b=c.createElement("div"),d="__sizzle__";b.innerHTML="<p class='TEST'></p>";if(!b.querySelectorAll||b.querySelectorAll(".TEST").length!==0){m=function(b,e,f,g){e=e||c;if(!g&&!m.isXML(e)){var h=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b);if(h&&(e.nodeType===1||e.nodeType===9)){if(h[1])return s(e.getElementsByTagName(b),f);if(h[2]&&o.find.CLASS&&e.getElementsByClassName)return s(e.getElementsByClassName(h[2]),f)}if(e.nodeType===9){if(b==="body"&&e.body)return s([e.body],f);if(h&&h[3]){var i=e.getElementById(h[3]);if(!i||!i.parentNode)return s([],f);if(i.id===h[3])return s([i],f)}try{return s(e.querySelectorAll(b),f)}catch(j){}}else if(e.nodeType===1&&e.nodeName.toLowerCase()!=="object"){var k=e,l=e.getAttribute("id"),n=l||d,p=e.parentNode,q=/^\s*[+~]/.test(b);l?n=n.replace(/'/g,"\\$&"):e.setAttribute("id",n),q&&p&&(e=e.parentNode);try{if(!q||p)return s(e.querySelectorAll("[id='"+n+"'] "+b),f)}catch(r){}finally{l||k.removeAttribute("id")}}}return a(b,e,f,g)};for(var e in a)m[e]=a[e];b=null}}(),function(){var a=c.documentElement,b=a.matchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||a.msMatchesSelector;if(b){var d=!b.call(c.createElement("div"),"div"),e=!1;try{b.call(c.documentElement,"[test!='']:sizzle")}catch(f){e=!0}m.matchesSelector=function(a,c){c=c.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!m.isXML(a))try{if(e||!o.match.PSEUDO.test(c)&&!/!=/.test(c)){var f=b.call(a,c);if(f||!d||a.document&&a.document.nodeType!==11)return f}}catch(g){}return m(c,null,null,[a]).length>0}}}(),function(){var a=c.createElement("div");a.innerHTML="<div class='test e'></div><div class='test'></div>";if(!!a.getElementsByClassName&&a.getElementsByClassName("e").length!==0){a.lastChild.className="e";if(a.getElementsByClassName("e").length===1)return;o.order.splice(1,0,"CLASS"),o.find.CLASS=function(a,b,c){if(typeof b.getElementsByClassName!="undefined"&&!c)return b.getElementsByClassName(a[1])},a=null}}(),c.documentElement.contains?m.contains=function(a,b){return a!==b&&(a.contains?a.contains(b):!0)}:c.documentElement.compareDocumentPosition?m.contains=function(a,b){return!!(a.compareDocumentPosition(b)&16)}:m.contains=function(){return!1},m.isXML=function(a){var b=(a?a.ownerDocument||a:0).documentElement;return b?b.nodeName!=="HTML":!1};var y=function(a,b,c){var d,e=[],f="",g=b.nodeType?[b]:b;while(d=o.match.PSEUDO.exec(a))f+=d[0],a=a.replace(o.match.PSEUDO,"");a=o.relative[a]?a+"*":a;for(var h=0,i=g.length;h<i;h++)m(a,g[h],e,c);return m.filter(f,e)};m.attr=f.attr,m.selectors.attrMap={},f.find=m,f.expr=m.selectors,f.expr[":"]=f.expr.filters,f.unique=m.uniqueSort,f.text=m.getText,f.isXMLDoc=m.isXML,f.contains=m.contains}();var L=/Until$/,M=/^(?:parents|prevUntil|prevAll)/,N=/,/,O=/^.[^:#\[\.,]*$/,P=Array.prototype.slice,Q=f.expr.match.POS,R={children:!0,contents:!0,next:!0,prev:!0};f.fn.extend({find:function(a){var b=this,c,d;if(typeof a!="string")return f(a).filter(function(){for(c=0,d=b.length;c<d;c++)if(f.contains(b[c],this))return!0});var e=this.pushStack("","find",a),g,h,i;for(c=0,d=this.length;c<d;c++){g=e.length,f.find(a,this[c],e);if(c>0)for(h=g;h<e.length;h++)for(i=0;i<g;i++)if(e[i]===e[h]){e.splice(h--,1);break}}return e},has:function(a){var b=f(a);return this.filter(function(){for(var a=0,c=b.length;a<c;a++)if(f.contains(this,b[a]))return!0})},not:function(a){return this.pushStack(T(this,a,!1),"not",a)},filter:function(a){return this.pushStack(T(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?Q.test(a)?f(a,this.context).index(this[0])>=0:f.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c=[],d,e,g=this[0];if(f.isArray(a)){var h=1;while(g&&g.ownerDocument&&g!==b){for(d=0;d<a.length;d++)f(g).is(a[d])&&c.push({selector:a[d],elem:g,level:h});g=g.parentNode,h++}return c}var i=Q.test(a)||typeof a!="string"?f(a,b||this.context):0;for(d=0,e=this.length;d<e;d++){g=this[d];while(g){if(i?i.index(g)>-1:f.find.matchesSelector(g,a)){c.push(g);break}g=g.parentNode;if(!g||!g.ownerDocument||g===b||g.nodeType===11)break}}c=c.length>1?f.unique(c):c;return this.pushStack(c,"closest",a)},index:function(a){if(!a)return this[0]&&this[0].parentNode?this.prevAll().length:-1;if(typeof a=="string")return f.inArray(this[0],f(a));return f.inArray(a.jquery?a[0]:a,this)},add:function(a,b){var c=typeof a=="string"?f(a,b):f.makeArray(a&&a.nodeType?[a]:a),d=f.merge(this.get(),c);return this.pushStack(S(c[0])||S(d[0])?d:f.unique(d))},andSelf:function(){return this.add(this.prevObject)}}),f.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return f.dir(a,"parentNode")},parentsUntil:function(a,b,c){return f.dir(a,"parentNode",c)},next:function(a){return f.nth(a,2,"nextSibling")},prev:function(a){return f.nth(a,2,"previousSibling")},nextAll:function(a){return f.dir(a,"nextSibling")},prevAll:function(a){return f.dir(a,"previousSibling")},nextUntil:function(a,b,c){return f.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return f.dir(a,"previousSibling",c)},siblings:function(a){return f.sibling(a.parentNode.firstChild,a)},children:function(a){return f.sibling(a.firstChild)},contents:function(a){return f.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:f.makeArray(a.childNodes)}},function(a,b){f.fn[a]=function(c,d){var e=f.map(this,b,c);L.test(a)||(d=c),d&&typeof d=="string"&&(e=f.filter(d,e)),e=this.length>1&&!R[a]?f.unique(e):e,(this.length>1||N.test(d))&&M.test(a)&&(e=e.reverse());return this.pushStack(e,a,P.call(arguments).join(","))}}),f.extend({filter:function(a,b,c){c&&(a=":not("+a+")");return b.length===1?f.find.matchesSelector(b[0],a)?[b[0]]:[]:f.find.matches(a,b)},dir:function(a,c,d){var e=[],g=a[c];while(g&&g.nodeType!==9&&(d===b||g.nodeType!==1||!f(g).is(d)))g.nodeType===1&&e.push(g),g=g[c];return e},nth:function(a,b,c,d){b=b||1;var e=0;for(;a;a=a[c])if(a.nodeType===1&&++e===b)break;return a},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var V="abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",W=/ jQuery\d+="(?:\d+|null)"/g,X=/^\s+/,Y=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,Z=/<([\w:]+)/,$=/<tbody/i,_=/<|&#?\w+;/,ba=/<(?:script|style)/i,bb=/<(?:script|object|embed|option|style)/i,bc=new RegExp("<(?:"+V+")","i"),bd=/checked\s*(?:[^=]|=\s*.checked.)/i,be=/\/(java|ecma)script/i,bf=/^\s*<!(?:\[CDATA\[|\-\-)/,bg={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},bh=U(c);bg.optgroup=bg.option,bg.tbody=bg.tfoot=bg.colgroup=bg.caption=bg.thead,bg.th=bg.td,f.support.htmlSerialize||(bg._default=[1,"div<div>","</div>"]),f.fn.extend({text:function(a){if(f.isFunction(a))return this.each(function(b){var c=f(this);c.text(a.call(this,b,c.text()))});if(typeof a!="object"&&a!==b)return this.empty().append((this[0]&&this[0].ownerDocument||c).createTextNode(a));return f.text(this)},wrapAll:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapAll(a.call(this,b))});if(this[0]){var b=f(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapInner(a.call(this,b))});return this.each(function(){var b=f(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=f.isFunction(a);return this.each(function(c){f(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){f.nodeName(this,"body")||f(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=f.clean(arguments);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,f.clean(arguments));return a}},remove:function(a,b){for(var c=0,d;(d=this[c])!=null;c++)if(!a||f.filter(a,[d]).length)!b&&d.nodeType===1&&(f.cleanData(d.getElementsByTagName("*")),f.cleanData([d])),d.parentNode&&d.parentNode.removeChild(d);return this},empty:function()
+{for(var a=0,b;(b=this[a])!=null;a++){b.nodeType===1&&f.cleanData(b.getElementsByTagName("*"));while(b.firstChild)b.removeChild(b.firstChild)}return this},clone:function(a,b){a=a==null?!1:a,b=b==null?a:b;return this.map(function(){return f.clone(this,a,b)})},html:function(a){if(a===b)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(W,""):null;if(typeof a=="string"&&!ba.test(a)&&(f.support.leadingWhitespace||!X.test(a))&&!bg[(Z.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Y,"<$1></$2>");try{for(var c=0,d=this.length;c<d;c++)this[c].nodeType===1&&(f.cleanData(this[c].getElementsByTagName("*")),this[c].innerHTML=a)}catch(e){this.empty().append(a)}}else f.isFunction(a)?this.each(function(b){var c=f(this);c.html(a.call(this,b,c.html()))}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&this[0].parentNode){if(f.isFunction(a))return this.each(function(b){var c=f(this),d=c.html();c.replaceWith(a.call(this,b,d))});typeof a!="string"&&(a=f(a).detach());return this.each(function(){var b=this.nextSibling,c=this.parentNode;f(this).remove(),b?f(b).before(a):f(c).append(a)})}return this.length?this.pushStack(f(f.isFunction(a)?a():a),"replaceWith",a):this},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){var e,g,h,i,j=a[0],k=[];if(!f.support.checkClone&&arguments.length===3&&typeof j=="string"&&bd.test(j))return this.each(function(){f(this).domManip(a,c,d,!0)});if(f.isFunction(j))return this.each(function(e){var g=f(this);a[0]=j.call(this,e,c?g.html():b),g.domManip(a,c,d)});if(this[0]){i=j&&j.parentNode,f.support.parentNode&&i&&i.nodeType===11&&i.childNodes.length===this.length?e={fragment:i}:e=f.buildFragment(a,this,k),h=e.fragment,h.childNodes.length===1?g=h=h.firstChild:g=h.firstChild;if(g){c=c&&f.nodeName(g,"tr");for(var l=0,m=this.length,n=m-1;l<m;l++)d.call(c?bi(this[l],g):this[l],e.cacheable||m>1&&l<n?f.clone(h,!0,!0):h)}k.length&&f.each(k,bp)}return this}}),f.buildFragment=function(a,b,d){var e,g,h,i,j=a[0];b&&b[0]&&(i=b[0].ownerDocument||b[0]),i.createDocumentFragment||(i=c),a.length===1&&typeof j=="string"&&j.length<512&&i===c&&j.charAt(0)==="<"&&!bb.test(j)&&(f.support.checkClone||!bd.test(j))&&(f.support.html5Clone||!bc.test(j))&&(g=!0,h=f.fragments[j],h&&h!==1&&(e=h)),e||(e=i.createDocumentFragment(),f.clean(a,i,e,d)),g&&(f.fragments[j]=h?e:1);return{fragment:e,cacheable:g}},f.fragments={},f.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){f.fn[a]=function(c){var d=[],e=f(c),g=this.length===1&&this[0].parentNode;if(g&&g.nodeType===11&&g.childNodes.length===1&&e.length===1){e[b](this[0]);return this}for(var h=0,i=e.length;h<i;h++){var j=(h>0?this.clone(!0):this).get();f(e[h])[b](j),d=d.concat(j)}return this.pushStack(d,a,e.selector)}}),f.extend({clone:function(a,b,c){var d,e,g,h=f.support.html5Clone||!bc.test("<"+a.nodeName)?a.cloneNode(!0):bo(a);if((!f.support.noCloneEvent||!f.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!f.isXMLDoc(a)){bk(a,h),d=bl(a),e=bl(h);for(g=0;d[g];++g)e[g]&&bk(d[g],e[g])}if(b){bj(a,h);if(c){d=bl(a),e=bl(h);for(g=0;d[g];++g)bj(d[g],e[g])}}d=e=null;return h},clean:function(a,b,d,e){var g;b=b||c,typeof b.createElement=="undefined"&&(b=b.ownerDocument||b[0]&&b[0].ownerDocument||c);var h=[],i;for(var j=0,k;(k=a[j])!=null;j++){typeof k=="number"&&(k+="");if(!k)continue;if(typeof k=="string")if(!_.test(k))k=b.createTextNode(k);else{k=k.replace(Y,"<$1></$2>");var l=(Z.exec(k)||["",""])[1].toLowerCase(),m=bg[l]||bg._default,n=m[0],o=b.createElement("div");b===c?bh.appendChild(o):U(b).appendChild(o),o.innerHTML=m[1]+k+m[2];while(n--)o=o.lastChild;if(!f.support.tbody){var p=$.test(k),q=l==="table"&&!p?o.firstChild&&o.firstChild.childNodes:m[1]==="<table>"&&!p?o.childNodes:[];for(i=q.length-1;i>=0;--i)f.nodeName(q[i],"tbody")&&!q[i].childNodes.length&&q[i].parentNode.removeChild(q[i])}!f.support.leadingWhitespace&&X.test(k)&&o.insertBefore(b.createTextNode(X.exec(k)[0]),o.firstChild),k=o.childNodes}var r;if(!f.support.appendChecked)if(k[0]&&typeof (r=k.length)=="number")for(i=0;i<r;i++)bn(k[i]);else bn(k);k.nodeType?h.push(k):h=f.merge(h,k)}if(d){g=function(a){return!a.type||be.test(a.type)};for(j=0;h[j];j++)if(e&&f.nodeName(h[j],"script")&&(!h[j].type||h[j].type.toLowerCase()==="text/javascript"))e.push(h[j].parentNode?h[j].parentNode.removeChild(h[j]):h[j]);else{if(h[j].nodeType===1){var s=f.grep(h[j].getElementsByTagName("script"),g);h.splice.apply(h,[j+1,0].concat(s))}d.appendChild(h[j])}}return h},cleanData:function(a){var b,c,d=f.cache,e=f.event.special,g=f.support.deleteExpando;for(var h=0,i;(i=a[h])!=null;h++){if(i.nodeName&&f.noData[i.nodeName.toLowerCase()])continue;c=i[f.expando];if(c){b=d[c];if(b&&b.events){for(var j in b.events)e[j]?f.event.remove(i,j):f.removeEvent(i,j,b.handle);b.handle&&(b.handle.elem=null)}g?delete i[f.expando]:i.removeAttribute&&i.removeAttribute(f.expando),delete d[c]}}}});var bq=/alpha\([^)]*\)/i,br=/opacity=([^)]*)/,bs=/([A-Z]|^ms)/g,bt=/^-?\d+(?:px)?$/i,bu=/^-?\d/,bv=/^([\-+])=([\-+.\de]+)/,bw={position:"absolute",visibility:"hidden",display:"block"},bx=["Left","Right"],by=["Top","Bottom"],bz,bA,bB;f.fn.css=function(a,c){if(arguments.length===2&&c===b)return this;return f.access(this,a,c,!0,function(a,c,d){return d!==b?f.style(a,c,d):f.css(a,c)})},f.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bz(a,"opacity","opacity");return c===""?"1":c}return a.style.opacity}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":f.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!!a&&a.nodeType!==3&&a.nodeType!==8&&!!a.style){var g,h,i=f.camelCase(c),j=a.style,k=f.cssHooks[i];c=f.cssProps[i]||i;if(d===b){if(k&&"get"in k&&(g=k.get(a,!1,e))!==b)return g;return j[c]}h=typeof d,h==="string"&&(g=bv.exec(d))&&(d=+(g[1]+1)*+g[2]+parseFloat(f.css(a,c)),h="number");if(d==null||h==="number"&&isNaN(d))return;h==="number"&&!f.cssNumber[i]&&(d+="px");if(!k||!("set"in k)||(d=k.set(a,d))!==b)try{j[c]=d}catch(l){}}},css:function(a,c,d){var e,g;c=f.camelCase(c),g=f.cssHooks[c],c=f.cssProps[c]||c,c==="cssFloat"&&(c="float");if(g&&"get"in g&&(e=g.get(a,!0,d))!==b)return e;if(bz)return bz(a,c)},swap:function(a,b,c){var d={};for(var e in b)d[e]=a.style[e],a.style[e]=b[e];c.call(a);for(e in b)a.style[e]=d[e]}}),f.curCSS=f.css,f.each(["height","width"],function(a,b){f.cssHooks[b]={get:function(a,c,d){var e;if(c){if(a.offsetWidth!==0)return bC(a,b,d);f.swap(a,bw,function(){e=bC(a,b,d)});return e}},set:function(a,b){if(!bt.test(b))return b;b=parseFloat(b);if(b>=0)return b+"px"}}}),f.support.opacity||(f.cssHooks.opacity={get:function(a,b){return br.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=f.isNumeric(b)?"alpha(opacity="+b*100+")":"",g=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&f.trim(g.replace(bq,""))===""){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bq.test(g)?g.replace(bq,e):g+" "+e}}),f(function(){f.support.reliableMarginRight||(f.cssHooks.marginRight={get:function(a,b){var c;f.swap(a,{display:"inline-block"},function(){b?c=bz(a,"margin-right","marginRight"):c=a.style.marginRight});return c}})}),c.defaultView&&c.defaultView.getComputedStyle&&(bA=function(a,b){var c,d,e;b=b.replace(bs,"-$1").toLowerCase(),(d=a.ownerDocument.defaultView)&&(e=d.getComputedStyle(a,null))&&(c=e.getPropertyValue(b),c===""&&!f.contains(a.ownerDocument.documentElement,a)&&(c=f.style(a,b)));return c}),c.documentElement.currentStyle&&(bB=function(a,b){var c,d,e,f=a.currentStyle&&a.currentStyle[b],g=a.style;f===null&&g&&(e=g[b])&&(f=e),!bt.test(f)&&bu.test(f)&&(c=g.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),g.left=b==="fontSize"?"1em":f||0,f=g.pixelLeft+"px",g.left=c,d&&(a.runtimeStyle.left=d));return f===""?"auto":f}),bz=bA||bB,f.expr&&f.expr.filters&&(f.expr.filters.hidden=function(a){var b=a.offsetWidth,c=a.offsetHeight;return b===0&&c===0||!f.support.reliableHiddenOffsets&&(a.style&&a.style.display||f.css(a,"display"))==="none"},f.expr.filters.visible=function(a){return!f.expr.filters.hidden(a)});var bD=/%20/g,bE=/\[\]$/,bF=/\r?\n/g,bG=/#.*$/,bH=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,bI=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,bJ=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,bK=/^(?:GET|HEAD)$/,bL=/^\/\//,bM=/\?/,bN=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,bO=/^(?:select|textarea)/i,bP=/\s+/,bQ=/([?&])_=[^&]*/,bR=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,bS=f.fn.load,bT={},bU={},bV,bW,bX=["*/"]+["*"];try{bV=e.href}catch(bY){bV=c.createElement("a"),bV.href="",bV=bV.href}bW=bR.exec(bV.toLowerCase())||[],f.fn.extend({load:function(a,c,d){if(typeof a!="string"&&bS)return bS.apply(this,arguments);if(!this.length)return this;var e=a.indexOf(" ");if(e>=0){var g=a.slice(e,a.length);a=a.slice(0,e)}var h="GET";c&&(f.isFunction(c)?(d=c,c=b):typeof c=="object"&&(c=f.param(c,f.ajaxSettings.traditional),h="POST"));var i=this;f.ajax({url:a,type:h,dataType:"html",data:c,complete:function(a,b,c){c=a.responseText,a.isResolved()&&(a.done(function(a){c=a}),i.html(g?f("<div>").append(c.replace(bN,"")).find(g):c)),d&&i.each(d,[c,b,a])}});return this},serialize:function(){return f.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?f.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bO.test(this.nodeName)||bI.test(this.type))}).map(function(a,b){var c=f(this).val();return c==null?null:f.isArray(c)?f.map(c,function(a,c){return{name:b.name,value:a.replace(bF,"\r\n")}}):{name:b.name,value:c.replace(bF,"\r\n")}}).get()}}),f.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){f.fn[b]=function(a){return this.on(b,a)}}),f.each(["get","post"],function(a,c){f[c]=function(a,d,e,g){f.isFunction(d)&&(g=g||e,e=d,d=b);return f.ajax({type:c,url:a,data:d,success:e,dataType:g})}}),f.extend({getScript:function(a,c){return f.get(a,b,c,"script")},getJSON:function(a,b,c){return f.get(a,b,c,"json")},ajaxSetup:function(a,b){b?b_(a,f.ajaxSettings):(b=a,a=f.ajaxSettings),b_(a,b);return a},ajaxSettings:{url:bV,isLocal:bJ.test(bW[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":bX},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":f.parseJSON,"text xml":f.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:bZ(bT),ajaxTransport:bZ(bU),ajax:function(a,c){function w(a,c,l,m){if(s!==2){s=2,q&&clearTimeout(q),p=b,n=m||"",v.readyState=a>0?4:0;var o,r,u,w=c,x=l?cb(d,v,l):b,y,z;if(a>=200&&a<300||a===304){if(d.ifModified){if(y=v.getResponseHeader("Last-Modified"))f.lastModified[k]=y;if(z=v.getResponseHeader("Etag"))f.etag[k]=z}if(a===304)w="notmodified",o=!0;else try{r=cc(d,x),w="success",o=!0}catch(A){w="parsererror",u=A}}else{u=w;if(!w||a)w="error",a<0&&(a=0)}v.status=a,v.statusText=""+(c||w),o?h.resolveWith(e,[r,w,v]):h.rejectWith(e,[v,w,u]),v.statusCode(j),j=b,t&&g.trigger("ajax"+(o?"Success":"Error"),[v,d,o?r:u]),i.fireWith(e,[v,w]),t&&(g.trigger("ajaxComplete",[v,d]),--f.active||f.event.trigger("ajaxStop"))}}typeof a=="object"&&(c=a,a=b),c=c||{};var d=f.ajaxSetup({},c),e=d.context||d,g=e!==d&&(e.nodeType||e instanceof f)?f(e):f.event,h=f.Deferred(),i=f.Callbacks("once memory"),j=d.statusCode||{},k,l={},m={},n,o,p,q,r,s=0,t,u,v={readyState:0,setRequestHeader:function(a,b){if(!s){var c=a.toLowerCase();a=m[c]=m[c]||a,l[a]=b}return this},getAllResponseHeaders:function(){return s===2?n:null},getResponseHeader:function(a){var c;if(s===2){if(!o){o={};while(c=bH.exec(n))o[c[1].toLowerCase()]=c[2]}c=o[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){s||(d.mimeType=a);return this},abort:function(a){a=a||"abort",p&&p.abort(a),w(0,a);return this}};h.promise(v),v.success=v.done,v.error=v.fail,v.complete=i.add,v.statusCode=function(a){if(a){var b;if(s<2)for(b in a)j[b]=[j[b],a[b]];else b=a[v.status],v.then(b,b)}return this},d.url=((a||d.url)+"").replace(bG,"").replace(bL,bW[1]+"//"),d.dataTypes=f.trim(d.dataType||"*").toLowerCase().split(bP),d.crossDomain==null&&(r=bR.exec(d.url.toLowerCase()),d.crossDomain=!(!r||r[1]==bW[1]&&r[2]==bW[2]&&(r[3]||(r[1]==="http:"?80:443))==(bW[3]||(bW[1]==="http:"?80:443)))),d.data&&d.processData&&typeof d.data!="string"&&(d.data=f.param(d.data,d.traditional)),b$(bT,d,c,v);if(s===2)return!1;t=d.global,d.type=d.type.toUpperCase(),d.hasContent=!bK.test(d.type),t&&f.active++===0&&f.event.trigger("ajaxStart");if(!d.hasContent){d.data&&(d.url+=(bM.test(d.url)?"&":"?")+d.data,delete d.data),k=d.url;if(d.cache===!1){var x=f.now(),y=d.url.replace(bQ,"$1_="+x);d.url=y+(y===d.url?(bM.test(d.url)?"&":"?")+"_="+x:"")}}(d.data&&d.hasContent&&d.contentType!==!1||c.contentType)&&v.setRequestHeader("Content-Type",d.contentType),d.ifModified&&(k=k||d.url,f.lastModified[k]&&v.setRequestHeader("If-Modified-Since",f.lastModified[k]),f.etag[k]&&v.setRequestHeader("If-None-Match",f.etag[k])),v.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(d.dataTypes[0]!=="*"?", "+bX+"; q=0.01":""):d.accepts["*"]);for(u in d.headers)v.setRequestHeader(u,d.headers[u]);if(d.beforeSend&&(d.beforeSend.call(e,v,d)===!1||s===2)){v.abort();return!1}for(u in{success:1,error:1,complete:1})v[u](d[u]);p=b$(bU,d,c,v);if(!p)w(-1,"No Transport");else{v.readyState=1,t&&g.trigger("ajaxSend",[v,d]),d.async&&d.timeout>0&&(q=setTimeout(function(){v.abort("timeout")},d.timeout));try{s=1,p.send(l,w)}catch(z){if(s<2)w(-1,z);else throw z}}return v},param:function(a,c){var d=[],e=function(a,b){b=f.isFunction(b)?b():b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=f.ajaxSettings.traditional);if(f.isArray(a)||a.jquery&&!f.isPlainObject(a))f.each(a,function(){e(this.name,this.value)});else for(var g in a)ca(g,a[g],c,e);return d.join("&").replace(bD,"+")}}),f.extend({active:0,lastModified:{},etag:{}});var cd=f.now(),ce=/(\=)\?(&|$)|\?\?/i;f.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return f.expando+"_"+cd++}}),f.ajaxPrefilter("json jsonp",function(b,c,d){var e=b.contentType==="application/x-www-form-urlencoded"&&typeof b.data=="string";if(b.dataTypes[0]==="jsonp"||b.jsonp!==!1&&(ce.test(b.url)||e&&ce.test(b.data))){var g,h=b.jsonpCallback=f.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2";b.jsonp!==!1&&(j=j.replace(ce,l),b.url===j&&(e&&(k=k.replace(ce,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},d.always(function(){a[h]=i,g&&f.isFunction(i)&&a[h](g[0])}),b.converters["script json"]=function(){g||f.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),f.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){f.globalEval(a);return a}}}),f.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),f.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(c||!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var cf=a.ActiveXObject?function(){for(var a in ch)ch[a](0,1)}:!1,cg=0,ch;f.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&ci()||cj()}:ci,function(a){f.extend(f.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(f.ajaxSettings.xhr()),f.support.ajax&&f.ajaxTransport(function(c){if(!c.crossDomain||f.support.cors){var d;return{send:function(e,g){var h=c.xhr(),i,j;c.username?h.open(c.type,c.url,c.async,c.username,c.password):h.open(c.type,c.url,c.async);if(c.xhrFields)for(j in c.xhrFields)h[j]=c.xhrFields[j];c.mimeType&&h.overrideMimeType&&h.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(j in e)h.setRequestHeader(j,e[j])}catch(k){}h.send(c.hasContent&&c.data||null),d=function(a,e){var j,k,l,m,n;try{if(d&&(e||h.readyState===4)){d=b,i&&(h.onreadystatechange=f.noop,cf&&delete ch[i]);if(e)h.readyState!==4&&h.abort();else{j=h.status,l=h.getAllResponseHeaders(),m={},n=h.responseXML,n&&n.documentElement&&(m.xml=n),m.text=h.responseText;try{k=h.statusText}catch(o){k=""}!j&&c.isLocal&&!c.crossDomain?j=m.text?200:404:j===1223&&(j=204)}}}catch(p){e||g(-1,p)}m&&g(j,k,m,l)},!c.async||h.readyState===4?d():(i=++cg,cf&&(ch||(ch={},f(a).unload(cf)),ch[i]=d),h.onreadystatechange=d)},abort:function(){d&&d(0,1)}}}});var ck={},cl,cm,cn=/^(?:toggle|show|hide)$/,co=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,cp,cq=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],cr;f.fn.extend({show:function(a,b,c){var d,e;if(a||a===0)return this.animate(cu("show",3),a,b,c);for(var g=0,h=this.length;g<h;g++)d=this[g],d.style&&(e=d.style.display,!f._data(d,"olddisplay")&&e==="none"&&(e=d.style.display=""),e===""&&f.css(d,"display")==="none"&&f._data(d,"olddisplay",cv(d.nodeName)));for(g=0;g<h;g++){d=this[g];if(d.style){e=d.style.display;if(e===""||e==="none")d.style.display=f._data(d,"olddisplay")||""}}return this},hide:function(a,b,c){if(a||a===0)return this.animate(cu("hide",3),a,b,c);var d,e,g=0,h=this.length;for(;g<h;g++)d=this[g],d.style&&(e=f.css(d,"display"),e!=="none"&&!f._data(d,"olddisplay")&&f._data(d,"olddisplay",e));for(g=0;g<h;g++)this[g].style&&(this[g].style.display="none");return this},_toggle:f.fn.toggle,toggle:function(a,b,c){var d=typeof a=="boolean";f.isFunction(a)&&f.isFunction(b)?this._toggle.apply(this,arguments):a==null||d?this.each(function(){var b=d?a:f(this).is(":hidden");f(this)[b?"show":"hide"]()}):this.animate(cu("toggle",3),a,b,c);return this},fadeTo:function(a,b,c,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){function g(){e.queue===!1&&f._mark(this);var b=f.extend({},e),c=this.nodeType===1,d=c&&f(this).is(":hidden"),g,h,i,j,k,l,m,n,o;b.animatedProperties={};for(i in a){g=f.camelCase(i),i!==g&&(a[g]=a[i],delete a[i]),h=a[g],f.isArray(h)?(b.animatedProperties[g]=h[1],h=a[g]=h[0]):b.animatedProperties[g]=b.specialEasing&&b.specialEasing[g]||b.easing||"swing";if(h==="hide"&&d||h==="show"&&!d)return b.complete.call(this);c&&(g==="height"||g==="width")&&(b.overflow=[this.style.overflow,this.style.overflowX,this.style.overflowY],f.css(this,"display")==="inline"&&f.css(this,"float")==="none"&&(!f.support.inlineBlockNeedsLayout||cv(this.nodeName)==="inline"?this.style.display="inline-block":this.style.zoom=1))}b.overflow!=null&&(this.style.overflow="hidden");for(i in a)j=new f.fx(this,b,i),h=a[i],cn.test(h)?(o=f._data(this,"toggle"+i)||(h==="toggle"?d?"show":"hide":0),o?(f._data(this,"toggle"+i,o==="show"?"hide":"show"),j[o]()):j[h]()):(k=co.exec(h),l=j.cur(),k?(m=parseFloat(k[2]),n=k[3]||(f.cssNumber[i]?"":"px"),n!=="px"&&(f.style(this,i,(m||1)+n),l=(m||1)/j.cur()*l,f.style(this,i,l+n)),k[1]&&(m=(k[1]==="-="?-1:1)*m+l),j.custom(l,m,n)):j.custom(l,h,""));return!0}var e=f.speed(b,c,d);if(f.isEmptyObject(a))return this.each(e.complete,[!1]);a=f.extend({},a);return e.queue===!1?this.each(g):this.queue(e.queue,g)},stop:function(a,c,d){typeof a!="string"&&(d=c,c=a,a=b),c&&a!==!1&&this.queue(a||"fx",[]);return this.each(function(){function h(a,b,c){var e=b[c];f.removeData(a,c,!0),e.stop(d)}var b,c=!1,e=f.timers,g=f._data(this);d||f._unmark(!0,this);if(a==null)for(b in g)g[b]&&g[b].stop&&b.indexOf(".run")===b.length-4&&h(this,g,b);else g[b=a+".run"]&&g[b].stop&&h(this,g,b);for(b=e.length;b--;)e[b].elem===this&&(a==null||e[b].queue===a)&&(d?e[b](!0):e[b].saveState(),c=!0,e.splice(b,1));(!d||!c)&&f.dequeue(this,a)})}}),f.each({slideDown:cu("show",1),slideUp:cu("hide",1),slideToggle:cu("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){f.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),f.extend({speed:function(a,b,c){var d=a&&typeof a=="object"?f.extend({},a):{complete:c||!c&&b||f.isFunction(a)&&a,duration:a,easing:c&&b||b&&!f.isFunction(b)&&b};d.duration=f.fx.off?0:typeof d.duration=="number"?d.duration:d.duration in f.fx.speeds?f.fx.speeds[d.duration]:f.fx.speeds._default;if(d.queue==null||d.queue===!0)d.queue="fx";d.old=d.complete,d.complete=function(a){f.isFunction(d.old)&&d.old.call(this),d.queue?f.dequeue(this,d.queue):a!==!1&&f._unmark(this)};return d},easing:{linear:function(a,b,c,d){return c+d*a},swing:function(a,b,c,d){return(-Math.cos(a*Math.PI)/2+.5)*d+c}},timers:[],fx:function(a,b,c){this.options=b,this.elem=a,this.prop=c,b.orig=b.orig||{}}}),f.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this),(f.fx.step[this.prop]||f.fx.step._default)(this)},cur:function(){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];var a,b=f.css(this.elem,this.prop);return isNaN(a=parseFloat(b))?!b||b==="auto"?0:b:a},custom:function(a,c,d){function h(a){return e.step(a)}var e=this,g=f.fx;this.startTime=cr||cs(),this.end=c,this.now=this.start=a,this.pos=this.state=0,this.unit=d||this.unit||(f.cssNumber[this.prop]?"":"px"),h.queue=this.options.queue,h.elem=this.elem,h.saveState=function(){e.options.hide&&f._data(e.elem,"fxshow"+e.prop)===b&&f._data(e.elem,"fxshow"+e.prop,e.start)},h()&&f.timers.push(h)&&!cp&&(cp=setInterval(g.tick,g.interval))},show:function(){var a=f._data(this.elem,"fxshow"+this.prop);this.options.orig[this.prop]=a||f.style(this.elem,this.prop),this.options.show=!0,a!==b?this.custom(this.cur(),a):this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur()),f(this.elem).show()},hide:function(){this.options.orig[this.prop]=f._data(this.elem,"fxshow"+this.prop)||f.style(this.elem,this.prop),this.options.hide=!0,this.custom(this.cur(),0)},step:function(a){var b,c,d,e=cr||cs(),g=!0,h=this.elem,i=this.options;if(a||e>=i.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),i.animatedProperties[this.prop]=!0;for(b in i.animatedProperties)i.animatedProperties[b]!==!0&&(g=!1);if(g){i.overflow!=null&&!f.support.shrinkWrapBlocks&&f.each(["","X","Y"],function(a,b){h.style["overflow"+b]=i.overflow[a]}),i.hide&&f(h).hide();if(i.hide||i.show)for(b in i.animatedProperties)f.style(h,b,i.orig[b]),f.removeData(h,"fxshow"+b,!0),f.removeData(h,"toggle"+b,!0);d=i.complete,d&&(i.complete=!1,d.call(h))}return!1}i.duration==Infinity?this.now=e:(c=e-this.startTime,this.state=c/i.duration,this.pos=f.easing[i.animatedProperties[this.prop]](this.state,c,0,1,i.duration),this.now=this.start+(this.end-this.start)*this.pos),this.update();return!0}},f.extend(f.fx,{tick:function(){var a,b=f.timers,c=0;for(;c<b.length;c++)a=b[c],!a()&&b[c]===a&&b.splice(c--,1);b.length||f.fx.stop()},interval:13,stop:function(){clearInterval(cp),cp=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){f.style(a.elem,"opacity",a.now)},_default:function(a){a.elem.style&&a.elem.style[a.prop]!=null?a.elem.style[a.prop]=a.now+a.unit:a.elem[a.prop]=a.now}}}),f.each(["width","height"],function(a,b){f.fx.step[b]=function(a){f.style(a.elem,b,Math.max(0,a.now)+a.unit)}}),f.expr&&f.expr.filters&&(f.expr.filters.animated=function(a){return f.grep(f.timers,function(b){return a===b.elem}).length});var cw=/^t(?:able|d|h)$/i,cx=/^(?:body|html)$/i;"getBoundingClientRect"in c.documentElement?f.fn.offset=function(a){var b=this[0],c;if(a)return this.each(function(b){f.offset.setOffset(this,a,b)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return f.offset.bodyOffset(b);try{c=b.getBoundingClientRect()}catch(d){}var e=b.ownerDocument,g=e.documentElement;if(!c||!f.contains(g,b))return c?{top:c.top,left:c.left}:{top:0,left:0};var h=e.body,i=cy(e),j=g.clientTop||h.clientTop||0,k=g.clientLeft||h.clientLeft||0,l=i.pageYOffset||f.support.boxModel&&g.scrollTop||h.scrollTop,m=i.pageXOffset||f.support.boxModel&&g.scrollLeft||h.scrollLeft,n=c.top+l-j,o=c.left+m-k;return{top:n,left:o}}:f.fn.offset=function(a){var b=this[0];if(a)return this.each(function(b){f.offset.setOffset(this,a,b)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return f.offset.bodyOffset(b);var c,d=b.offsetParent,e=b,g=b.ownerDocument,h=g.documentElement,i=g.body,j=g.defaultView,k=j?j.getComputedStyle(b,null):b.currentStyle,l=b.offsetTop,m=b.offsetLeft;while((b=b.parentNode)&&b!==i&&b!==h){if(f.support.fixedPosition&&k.position==="fixed")break;c=j?j.getComputedStyle(b,null):b.currentStyle,l-=b.scrollTop,m-=b.scrollLeft,b===d&&(l+=b.offsetTop,m+=b.offsetLeft,f.support.doesNotAddBorder&&(!f.support.doesAddBorderForTableAndCells||!cw.test(b.nodeName))&&(l+=parseFloat(c.borderTopWidth)||0,m+=parseFloat(c.borderLeftWidth)||0),e=d,d=b.offsetParent),f.support.subtractsBorderForOverflowNotVisible&&c.overflow!=="visible"&&(l+=parseFloat(c.borderTopWidth)||0,m+=parseFloat(c.borderLeftWidth)||0),k=c}if(k.position==="relative"||k.position==="static")l+=i.offsetTop,m+=i.offsetLeft;f.support.fixedPosition&&k.position==="fixed"&&(l+=Math.max(h.scrollTop,i.scrollTop),m+=Math.max(h.scrollLeft,i.scrollLeft));return{top:l,left:m}},f.offset={bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;f.support.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(f.css(a,"marginTop"))||0,c+=parseFloat(f.css(a,"marginLeft"))||0);return{top:b,left:c}},setOffset:function(a,b,c){var d=f.css(a,"position");d==="static"&&(a.style.position="relative");var e=f(a),g=e.offset(),h=f.css(a,"top"),i=f.css(a,"left"),j=(d==="absolute"||d==="fixed")&&f.inArray("auto",[h,i])>-1,k={},l={},m,n;j?(l=e.position(),m=l.top,n=l.left):(m=parseFloat(h)||0,n=parseFloat(i)||0),f.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):e.css(k)}},f.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),d=cx.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(f.css(a,"marginTop"))||0,c.left-=parseFloat(f.css(a,"marginLeft"))||0,d.top+=parseFloat(f.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(f.css(b[0],"borderLeftWidth"))||0;return{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&!cx.test(a.nodeName)&&f.css(a,"position")==="static")a=a.offsetParent;return a})}}),f.each(["Left","Top"],function(a,c){var d="scroll"+c;f.fn[d]=function(c){var e,g;if(c===b){e=this[0];if(!e)return null;g=cy(e);return g?"pageXOffset"in g?g[a?"pageYOffset":"pageXOffset"]:f.support.boxModel&&g.document.documentElement[d]||g.document.body[d]:e[d]}return this.each(function(){g=cy(this),g?g.scrollTo(a?f(g).scrollLeft():c,a?c:f(g).scrollTop()):this[d]=c})}}),f.each(["Height","Width"],function(a,c){var d=c.toLowerCase();f.fn["inner"+c]=function(){var a=this[0];return a?a.style?parseFloat(f.css(a,d,"padding")):this[d]():null},f.fn["outer"+c]=function(a){var b=this[0];return b?b.style?parseFloat(f.css(b,d,a?"margin":"border")):this[d]():null},f.fn[d]=function(a){var e=this[0];if(!e)return a==null?null:this;if(f.isFunction(a))return this.each(function(b){var c=f(this);c[d](a.call(this,b,c[d]()))});if(f.isWindow(e)){var g=e.document.documentElement["client"+c],h=e.document.body;return e.document.compatMode==="CSS1Compat"&&g||h&&h["client"+c]||g}if(e.nodeType===9)return Math.max(e.documentElement["client"+c],e.body["scroll"+c],e.documentElement["scroll"+c],e.body["offset"+c],e.documentElement["offset"+c]);if(a===b){var i=f.css(e,d),j=parseFloat(i);return f.isNumeric(j)?j:i}return this.css(d,typeof a=="string"?a:a+"px")}}),a.jQuery=a.$=f,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return f})})(window);
+'''
+
+g_raphael_js = r'''
+Raphael.el.popup=function(d,k,h,g){var c=this.paper||this[0].paper,f,j,b,e,a;if(!c){return}switch(this.type){case"text":case"circle":case"ellipse":b=true;break;default:b=false}d=d==null?"up":d;k=k||5;f=this.getBBox();h=typeof h=="number"?h:(b?f.x+f.width/2:f.x);g=typeof g=="number"?g:(b?f.y+f.height/2:f.y);e=Math.max(f.width/2-k,0);a=Math.max(f.height/2-k,0);this.translate(h-f.x-(b?f.width/2:0),g-f.y-(b?f.height/2:0));f=this.getBBox();var i={up:["M",h,g,"l",-k,-k,-e,0,"a",k,k,0,0,1,-k,-k,"l",0,-f.height,"a",k,k,0,0,1,k,-k,"l",k*2+e*2,0,"a",k,k,0,0,1,k,k,"l",0,f.height,"a",k,k,0,0,1,-k,k,"l",-e,0,"z"].join(","),down:["M",h,g,"l",k,k,e,0,"a",k,k,0,0,1,k,k,"l",0,f.height,"a",k,k,0,0,1,-k,k,"l",-(k*2+e*2),0,"a",k,k,0,0,1,-k,-k,"l",0,-f.height,"a",k,k,0,0,1,k,-k,"l",e,0,"z"].join(","),left:["M",h,g,"l",-k,k,0,a,"a",k,k,0,0,1,-k,k,"l",-f.width,0,"a",k,k,0,0,1,-k,-k,"l",0,-(k*2+a*2),"a",k,k,0,0,1,k,-k,"l",f.width,0,"a",k,k,0,0,1,k,k,"l",0,a,"z"].join(","),right:["M",h,g,"l",k,-k,0,-a,"a",k,k,0,0,1,k,-k,"l",f.width,0,"a",k,k,0,0,1,k,k,"l",0,k*2+a*2,"a",k,k,0,0,1,-k,k,"l",-f.width,0,"a",k,k,0,0,1,-k,-k,"l",0,-a,"z"].join(",")};j={up:{x:-!b*(f.width/2),y:-k*2-(b?f.height/2:f.height)},down:{x:-!b*(f.width/2),y:k*2+(b?f.height/2:f.height)},left:{x:-k*2-(b?f.width/2:f.width),y:-!b*(f.height/2)},right:{x:k*2+(b?f.width/2:f.width),y:-!b*(f.height/2)}}[d];this.translate(j.x,j.y);return c.path(i[d]).attr({fill:"#000",stroke:"none"}).insertBefore(this.node?this:this[0])};Raphael.el.tag=function(f,b,l,k){var i=3,e=this.paper||this[0].paper;if(!e){return}var c=e.path().attr({fill:"#000",stroke:"#000"}),j=this.getBBox(),m,h,a,g;switch(this.type){case"text":case"circle":case"ellipse":a=true;break;default:a=false}f=f||0;l=typeof l=="number"?l:(a?j.x+j.width/2:j.x);k=typeof k=="number"?k:(a?j.y+j.height/2:j.y);b=b==null?5:b;h=0.5522*b;if(j.height>=b*2){c.attr({path:["M",l,k+b,"a",b,b,0,1,1,0,-b*2,b,b,0,1,1,0,b*2,"m",0,-b*2-i,"a",b+i,b+i,0,1,0,0,(b+i)*2,"L",l+b+i,k+j.height/2+i,"l",j.width+2*i,0,0,-j.height-2*i,-j.width-2*i,0,"L",l,k-b-i].join(",")})}else{m=Math.sqrt(Math.pow(b+i,2)-Math.pow(j.height/2+i,2));c.attr({path:["M",l,k+b,"c",-h,0,-b,h-b,-b,-b,0,-h,b-h,-b,b,-b,h,0,b,b-h,b,b,0,h,h-b,b,-b,b,"M",l+m,k-j.height/2-i,"a",b+i,b+i,0,1,0,0,j.height+2*i,"l",b+i-m+j.width+2*i,0,0,-j.height-2*i,"L",l+m,k-j.height/2-i].join(",")})}f=360-f;c.rotate(f,l,k);if(this.attrs){this.attr(this.attrs.x?"x":"cx",l+b+i+(!a?this.type=="text"?j.width:0:j.width/2)).attr("y",a?k:k-j.height/2);this.rotate(f,l,k);f>90&&f<270&&this.attr(this.attrs.x?"x":"cx",l-b-i-(!a?j.width:j.width/2)).rotate(180,l,k)}else{if(f>90&&f<270){this.translate(l-j.x-j.width-b-i,k-j.y-j.height/2);this.rotate(f-180,j.x+j.width+b+i,j.y+j.height/2)}else{this.translate(l-j.x+b+i,k-j.y-j.height/2);this.rotate(f,j.x-b-i,j.y+j.height/2)}}return c.insertBefore(this.node?this:this[0])};Raphael.el.drop=function(d,g,f){var e=this.getBBox(),c=this.paper||this[0].paper,a,j,b,i,h;if(!c){return}switch(this.type){case"text":case"circle":case"ellipse":a=true;break;default:a=false}d=d||0;g=typeof g=="number"?g:(a?e.x+e.width/2:e.x);f=typeof f=="number"?f:(a?e.y+e.height/2:e.y);j=Math.max(e.width,e.height)+Math.min(e.width,e.height);b=c.path(["M",g,f,"l",j,0,"A",j*0.4,j*0.4,0,1,0,g+j*0.7,f-j*0.7,"z"]).attr({fill:"#000",stroke:"none"}).rotate(22.5-d,g,f);d=(d+90)*Math.PI/180;i=(g+j*Math.sin(d))-(a?0:e.width/2);h=(f+j*Math.cos(d))-(a?0:e.height/2);this.attrs?this.attr(this.attrs.x?"x":"cx",i).attr(this.attrs.y?"y":"cy",h):this.translate(i-e.x,h-e.y);return b.insertBefore(this.node?this:this[0])};Raphael.el.flag=function(e,k,j){var g=3,c=this.paper||this[0].paper;if(!c){return}var b=c.path().attr({fill:"#000",stroke:"#000"}),i=this.getBBox(),f=i.height/2,a;switch(this.type){case"text":case"circle":case"ellipse":a=true;break;default:a=false}e=e||0;k=typeof k=="number"?k:(a?i.x+i.width/2:i.x);j=typeof j=="number"?j:(a?i.y+i.height/2:i.y);b.attr({path:["M",k,j,"l",f+g,-f-g,i.width+2*g,0,0,i.height+2*g,-i.width-2*g,0,"z"].join(",")});e=360-e;b.rotate(e,k,j);if(this.attrs){this.attr(this.attrs.x?"x":"cx",k+f+g+(!a?this.type=="text"?i.width:0:i.width/2)).attr("y",a?j:j-i.height/2);this.rotate(e,k,j);e>90&&e<270&&this.attr(this.attrs.x?"x":"cx",k-f-g-(!a?i.width:i.width/2)).rotate(180,k,j)}else{if(e>90&&e<270){this.translate(k-i.x-i.width-f-g,j-i.y-i.height/2);this.rotate(e-180,i.x+i.width+f+g,i.y+i.height/2)}else{this.translate(k-i.x+f+g,j-i.y-i.height/2);this.rotate(e,i.x-f-g,i.y+i.height/2)}}return b.insertBefore(this.node?this:this[0])};Raphael.el.label=function(){var c=this.getBBox(),b=this.paper||this[0].paper,a=Math.min(20,c.width+10,c.height+10)/2;if(!b){return}return b.rect(c.x-a/2,c.y-a/2,c.width+a,c.height+a,a).attr({stroke:"none",fill:"#000"}).insertBefore(this.node?this:this[0])};Raphael.el.blob=function(z,j,i){var g=this.getBBox(),B=Math.PI/180,n=this.paper||this[0].paper,r,A,q;if(!n){return}switch(this.type){case"text":case"circle":case"ellipse":A=true;break;default:A=false}r=n.path().attr({fill:"#000",stroke:"none"});z=(+z+1?z:45)+90;q=Math.min(g.height,g.width);j=typeof j=="number"?j:(A?g.x+g.width/2:g.x);i=typeof i=="number"?i:(A?g.y+g.height/2:g.y);var m=Math.max(g.width+q,q*25/12),t=Math.max(g.height+q,q*25/12),u=j+q*Math.sin((z-22.5)*B),b=i+q*Math.cos((z-22.5)*B),v=j+q*Math.sin((z+22.5)*B),d=i+q*Math.cos((z+22.5)*B),o=(v-u)/2,l=(d-b)/2,f=m/2,e=t/2,s=-Math.sqrt(Math.abs(f*f*e*e-f*f*l*l-e*e*o*o)/(f*f*l*l+e*e*o*o)),c=s*f*l/e+(v+u)/2,a=s*-e*o/f+(d+b)/2;r.attr({x:c,y:a,path:["M",j,i,"L",v,d,"A",f,e,0,1,1,u,b,"z"].join(",")});this.translate(c-g.x-g.width/2,a-g.y-g.height/2);return r.insertBefore(this.node?this:this[0])};Raphael.fn.label=function(a,d,b){var c=this.set();b=this.text(a,d,b).attr(Raphael.g.txtattr);return c.push(b.label(),b)};Raphael.fn.popup=function(a,f,d,b,c){var e=this.set();d=this.text(a,f,d).attr(Raphael.g.txtattr);return e.push(d.popup(b,c),d)};Raphael.fn.tag=function(a,f,d,c,b){var e=this.set();d=this.text(a,f,d).attr(Raphael.g.txtattr);return e.push(d.tag(c,b),d)};Raphael.fn.flag=function(a,e,c,b){var d=this.set();c=this.text(a,e,c).attr(Raphael.g.txtattr);return d.push(c.flag(b),c)};Raphael.fn.drop=function(a,e,c,b){var d=this.set();c=this.text(a,e,c).attr(Raphael.g.txtattr);return d.push(c.drop(b),c)};Raphael.fn.blob=function(a,e,c,b){var d=this.set();c=this.text(a,e,c).attr(Raphael.g.txtattr);return d.push(c.blob(b),c)};Raphael.el.lighter=function(b){b=b||2;var a=[this.attrs.fill,this.attrs.stroke];this.fs=this.fs||[a[0],a[1]];a[0]=Raphael.rgb2hsb(Raphael.getRGB(a[0]).hex);a[1]=Raphael.rgb2hsb(Raphael.getRGB(a[1]).hex);a[0].b=Math.min(a[0].b*b,1);a[0].s=a[0].s/b;a[1].b=Math.min(a[1].b*b,1);a[1].s=a[1].s/b;this.attr({fill:"hsb("+[a[0].h,a[0].s,a[0].b]+")",stroke:"hsb("+[a[1].h,a[1].s,a[1].b]+")"});return this};Raphael.el.darker=function(b){b=b||2;var a=[this.attrs.fill,this.attrs.stroke];this.fs=this.fs||[a[0],a[1]];a[0]=Raphael.rgb2hsb(Raphael.getRGB(a[0]).hex);a[1]=Raphael.rgb2hsb(Raphael.getRGB(a[1]).hex);a[0].s=Math.min(a[0].s*b,1);a[0].b=a[0].b/b;a[1].s=Math.min(a[1].s*b,1);a[1].b=a[1].b/b;this.attr({fill:"hsb("+[a[0].h,a[0].s,a[0].b]+")",stroke:"hsb("+[a[1].h,a[1].s,a[1].b]+")"});return this};Raphael.el.resetBrightness=function(){if(this.fs){this.attr({fill:this.fs[0],stroke:this.fs[1]});delete this.fs}return this};(function(){var c=["lighter","darker","resetBrightness"],a=["popup","tag","flag","label","drop","blob"];for(var b in a){(function(d){Raphael.st[d]=function(){return Raphael.el[d].apply(this,arguments)}})(a[b])}for(var b in c){(function(d){Raphael.st[d]=function(){for(var e=0;e<this.length;e++){this[e][d].apply(this[e],arguments)}return this}})(c[b])}})();Raphael.g={shim:{stroke:"none",fill:"#000","fill-opacity":0},txtattr:{font:"12px Arial, sans-serif",fill:"#fff"},colors:(function(){var c=[0.6,0.2,0.05,0.1333,0.75,0],a=[];for(var b=0;b<10;b++){if(b<c.length){a.push("hsb("+c[b]+",.75, .75)")}else{a.push("hsb("+c[b-c.length]+", 1, .5)")}}return a})(),snapEnds:function(j,k,h){var e=j,l=k;if(e==l){return{from:e,to:l,power:0}}function m(d){return Math.abs(d-0.5)<0.25?~~(d)+0.5:Math.round(d)}var g=(l-e)/h,a=~~(g),c=a,b=0;if(a){while(c){b--;c=~~(g*Math.pow(10,b))/Math.pow(10,b)}b++}else{while(!a){b=b||1;a=~~(g*Math.pow(10,b))/Math.pow(10,b);b++}b&&b--}l=m(k*Math.pow(10,b))/Math.pow(10,b);if(l<k){l=m((k+0.5)*Math.pow(10,b))/Math.pow(10,b)}e=m((j-(b>0?0:0.5))*Math.pow(10,b))/Math.pow(10,b);return{from:e,to:l,power:b}},axis:function(p,o,k,D,e,G,g,J,h,a,q){a=a==null?2:a;h=h||"t";G=G||10;q=arguments[arguments.length-1];var C=h=="|"||h==" "?["M",p+0.5,o,"l",0,0.001]:g==1||g==3?["M",p+0.5,o,"l",0,-k]:["M",p,o+0.5,"l",k,0],s=this.snapEnds(D,e,G),H=s.from,z=s.to,F=s.power,E=0,w={font:"11px 'Fontin Sans', Fontin-Sans, sans-serif"},v=q.set(),I;I=(z-H)/G;var n=H,m=F>0?F:0;r=k/G;if(+g==1||+g==3){var b=o,u=(g-1?1:-1)*(a+3+!!(g-1));while(b>=o-k){h!="-"&&h!=" "&&(C=C.concat(["M",p-(h=="+"||h=="|"?a:!(g-1)*a*2),b+0.5,"l",a*2+1,0]));v.push(q.text(p+u,b,(J&&J[E++])||(Math.round(n)==n?n:+n.toFixed(m))).attr(w).attr({"text-anchor":g-1?"start":"end"}));n+=I;b-=r}if(Math.round(b+r-(o-k))){h!="-"&&h!=" "&&(C=C.concat(["M",p-(h=="+"||h=="|"?a:!(g-1)*a*2),o-k+0.5,"l",a*2+1,0]));v.push(q.text(p+u,o-k,(J&&J[E])||(Math.round(n)==n?n:+n.toFixed(m))).attr(w).attr({"text-anchor":g-1?"start":"end"}))}}else{n=H;m=(F>0)*F;u=(g?-1:1)*(a+9+!g);var c=p,r=k/G,A=0,B=0;while(c<=p+k){h!="-"&&h!=" "&&(C=C.concat(["M",c+0.5,o-(h=="+"?a:!!g*a*2),"l",0,a*2+1]));v.push(A=q.text(c,o+u,(J&&J[E++])||(Math.round(n)==n?n:+n.toFixed(m))).attr(w));var l=A.getBBox();if(B>=l.x-5){v.pop(v.length-1).remove()}else{B=l.x+l.width}n+=I;c+=r}if(Math.round(c-r-p-k)){h!="-"&&h!=" "&&(C=C.concat(["M",p+k+0.5,o-(h=="+"?a:!!g*a*2),"l",0,a*2+1]));v.push(q.text(p+k,o+u,(J&&J[E])||(Math.round(n)==n?n:+n.toFixed(m))).attr(w))}}var K=q.path(C);K.text=v;K.all=q.set([K,v]);K.remove=function(){this.text.remove();this.constructor.prototype.remove.call(this)};return K},labelise:function(a,c,b){if(a){return(a+"").replace(/(##+(?:\.#+)?)|(%%+(?:\.%+)?)/g,function(d,f,e){if(f){return(+c).toFixed(f.replace(/^#+\.?/g,"").length)}if(e){return(c*100/b).toFixed(e.replace(/^%+\.?/g,"").length)+"%"}})}else{return(+c).toFixed(0)}}};
+'''
+
+g_raphael_line_js = r'''
+(function(){function a(g,n){var f=g.length/n,h=0,e=f,m=0,i=[];while(h<g.length){e--;if(e<0){m+=g[h]*(1+e);i.push(m/f);m=g[h++]*-e;e+=f}else{m+=g[h++]}}return i}function d(f,e,p,n,k,j){var h=(p-f)/2,g=(k-p)/2,q=Math.atan((p-f)/Math.abs(n-e)),o=Math.atan((k-p)/Math.abs(n-j));q=e<n?Math.PI-q:q;o=j<n?Math.PI-o:o;var i=Math.PI/2-((q+o)%(Math.PI*2))/2,s=h*Math.sin(i+q),m=h*Math.cos(i+q),r=g*Math.sin(i+o),l=g*Math.cos(i+o);return{x1:p-s,y1:n+m,x2:p+r,y2:n+l}}function b(f,P,O,e,h,A,z,J){var s=this;J=J||{};if(!f.raphael.is(A[0],"array")){A=[A]}if(!f.raphael.is(z[0],"array")){z=[z]}var q=J.gutter||10,B=Math.max(A[0].length,z[0].length),t=J.symbol||"",S=J.colors||s.colors,v=null,p=null,ad=f.set(),T=[];for(var ac=0,L=z.length;ac<L;ac++){B=Math.max(B,z[ac].length)}var ae=f.set();for(ac=0,L=z.length;ac<L;ac++){if(J.shade){ae.push(f.path().attr({stroke:"none",fill:S[ac],opacity:J.nostroke?1:0.3}))}if(z[ac].length>e-2*q){z[ac]=a(z[ac],e-2*q);B=e-2*q}if(A[ac]&&A[ac].length>e-2*q){A[ac]=a(A[ac],e-2*q)}}var W=Array.prototype.concat.apply([],A),U=Array.prototype.concat.apply([],z),u=s.snapEnds(Math.min.apply(Math,W),Math.max.apply(Math,W),A[0].length-1),E=u.from,o=u.to,N=s.snapEnds(Math.min.apply(Math,U),Math.max.apply(Math,U),z[0].length-1),C=N.from,n=N.to,Z=(e-q*2)/((o-E)||1),V=(h-q*2)/((n-C)||1);var G=f.set();if(J.axis){var m=(J.axis+"").split(/[,\s]+/);+m[0]&&G.push(s.axis(P+q,O+q,e-2*q,E,o,J.axisxstep||Math.floor((e-2*q)/20),2,f));+m[1]&&G.push(s.axis(P+e-q,O+h-q,h-2*q,C,n,J.axisystep||Math.floor((h-2*q)/20),3,f));+m[2]&&G.push(s.axis(P+q,O+h-q,e-2*q,E,o,J.axisxstep||Math.floor((e-2*q)/20),0,f));+m[3]&&G.push(s.axis(P+q,O+h-q,h-2*q,C,n,J.axisystep||Math.floor((h-2*q)/20),1,f))}var M=f.set(),aa=f.set(),r;for(ac=0,L=z.length;ac<L;ac++){if(!J.nostroke){M.push(r=f.path().attr({stroke:S[ac],"stroke-width":J.width||2,"stroke-linejoin":"round","stroke-linecap":"round","stroke-dasharray":J.dash||""}))}var g=Raphael.is(t,"array")?t[ac]:t,H=f.set();T=[];for(var ab=0,w=z[ac].length;ab<w;ab++){var l=P+q+((A[ac]||A[0])[ab]-E)*Z,k=O+h-q-(z[ac][ab]-C)*V;(Raphael.is(g,"array")?g[ab]:g)&&H.push(f[Raphael.is(g,"array")?g[ab]:g](l,k,(J.width||2)*3).attr({fill:S[ac],stroke:"none"}));if(J.smooth){if(ab&&ab!=w-1){var R=P+q+((A[ac]||A[0])[ab-1]-E)*Z,F=O+h-q-(z[ac][ab-1]-C)*V,Q=P+q+((A[ac]||A[0])[ab+1]-E)*Z,D=O+h-q-(z[ac][ab+1]-C)*V,af=d(R,F,l,k,Q,D);T=T.concat([af.x1,af.y1,l,k,af.x2,af.y2])}if(!ab){T=["M",l,k,"C",l,k]}}else{T=T.concat([ab?"L":"M",l,k])}}if(J.smooth){T=T.concat([l,k,l,k])}aa.push(H);if(J.shade){ae[ac].attr({path:T.concat(["L",l,O+h-q,"L",P+q+((A[ac]||A[0])[0]-E)*Z,O+h-q,"z"]).join(",")})}!J.nostroke&&r.attr({path:T.join(",")})}function K(an){var ak=[];for(var al=0,ap=A.length;al<ap;al++){ak=ak.concat(A[al])}ak.sort();var aq=[],ah=[];for(al=0,ap=ak.length;al<ap;al++){ak[al]!=ak[al-1]&&aq.push(ak[al])&&ah.push(P+q+(ak[al]-E)*Z)}ak=aq;ap=ak.length;var ag=an||f.set();for(al=0;al<ap;al++){var Y=ah[al]-(ah[al]-(ah[al-1]||P))/2,ao=((ah[al+1]||P+e)-ah[al])/2+(ah[al]-(ah[al-1]||P))/2,x;an?(x={}):ag.push(x=f.rect(Y-1,O,Math.max(ao+1,1),h).attr({stroke:"none",fill:"#000",opacity:0}));x.values=[];x.symbols=f.set();x.y=[];x.x=ah[al];x.axis=ak[al];for(var aj=0,am=z.length;aj<am;aj++){aq=A[aj]||A[0];for(var ai=0,y=aq.length;ai<y;ai++){if(aq[ai]==ak[al]){x.values.push(z[aj][ai]);x.y.push(O+h-q-(z[aj][ai]-C)*V);x.symbols.push(ad.symbols[aj][ai])}}}an&&an.call(x)}!an&&(v=ag)}function I(al){var ah=al||f.set(),x;for(var aj=0,an=z.length;aj<an;aj++){for(var ai=0,ak=z[aj].length;ai<ak;ai++){var ag=P+q+((A[aj]||A[0])[ai]-E)*Z,am=P+q+((A[aj]||A[0])[ai?ai-1:1]-E)*Z,y=O+h-q-(z[aj][ai]-C)*V;al?(x={}):ah.push(x=f.circle(ag,y,Math.abs(am-ag)/2).attr({stroke:"none",fill:"#000",opacity:0}));x.x=ag;x.y=y;x.value=z[aj][ai];x.line=ad.lines[aj];x.shade=ad.shades[aj];x.symbol=ad.symbols[aj][ai];x.symbols=ad.symbols[aj];x.axis=(A[aj]||A[0])[ai];al&&al.call(x)}}!al&&(p=ah)}ad.push(M,ae,aa,G,v,p);ad.lines=M;ad.shades=ae;ad.symbols=aa;ad.axis=G;ad.hoverColumn=function(j,i){!v&&K();v.mouseover(j).mouseout(i);return this};ad.clickColumn=function(i){!v&&K();v.click(i);return this};ad.hrefColumn=function(Y){var ag=f.raphael.is(arguments[0],"array")?arguments[0]:arguments;if(!(arguments.length-1)&&typeof Y=="object"){for(var j in Y){for(var y=0,X=v.length;y<X;y++){if(v[y].axis==j){v[y].attr("href",Y[j])}}}}!v&&K();for(y=0,X=ag.length;y<X;y++){v[y]&&v[y].attr("href",ag[y])}return this};ad.hover=function(j,i){!p&&I();p.mouseover(j).mouseout(i);return this};ad.click=function(i){!p&&I();p.click(i);return this};ad.each=function(i){I(i);return this};ad.eachColumn=function(i){K(i);return this};return ad}var c=function(){};c.prototype=Raphael.g;b.prototype=new c;Raphael.fn.linechart=function(f,k,g,e,j,i,h){return new b(this,f,k,g,e,j,i,h)}})();
+'''
+
+raphael_js = r'''
+(function(a){var b="0.3.4",c="hasOwnProperty",d=/[\.\/]/,e="*",f=function(){},g=function(a,b){return a-b},h,i,j={n:{}},k=function(a,b){var c=j,d=i,e=Array.prototype.slice.call(arguments,2),f=k.listeners(a),l=0,m=!1,n,o=[],p={},q=[],r=h,s=[];h=a,i=0;for(var t=0,u=f.length;t<u;t++)"zIndex"in f[t]&&(o.push(f[t].zIndex),f[t].zIndex<0&&(p[f[t].zIndex]=f[t]));o.sort(g);while(o[l]<0){n=p[o[l++]],q.push(n.apply(b,e));if(i){i=d;return q}}for(t=0;t<u;t++){n=f[t];if("zIndex"in n)if(n.zIndex==o[l]){q.push(n.apply(b,e));if(i)break;do{l++,n=p[o[l]],n&&q.push(n.apply(b,e));if(i)break}while(n)}else p[n.zIndex]=n;else{q.push(n.apply(b,e));if(i)break}}i=d,h=r;return q.length?q:null};k.listeners=function(a){var b=a.split(d),c=j,f,g,h,i,k,l,m,n,o=[c],p=[];for(i=0,k=b.length;i<k;i++){n=[];for(l=0,m=o.length;l<m;l++){c=o[l].n,g=[c[b[i]],c[e]],h=2;while(h--)f=g[h],f&&(n.push(f),p=p.concat(f.f||[]))}o=n}return p},k.on=function(a,b){var c=a.split(d),e=j;for(var g=0,h=c.length;g<h;g++)e=e.n,!e[c[g]]&&(e[c[g]]={n:{}}),e=e[c[g]];e.f=e.f||[];for(g=0,h=e.f.length;g<h;g++)if(e.f[g]==b)return f;e.f.push(b);return function(a){+a==+a&&(b.zIndex=+a)}},k.stop=function(){i=1},k.nt=function(a){if(a)return(new RegExp("(?:\\.|\\/|^)"+a+"(?:\\.|\\/|$)")).test(h);return h},k.off=k.unbind=function(a,b){var f=a.split(d),g,h,i,k,l,m,n,o=[j];for(k=0,l=f.length;k<l;k++)for(m=0;m<o.length;m+=i.length-2){i=[m,1],g=o[m].n;if(f[k]!=e)g[f[k]]&&i.push(g[f[k]]);else for(h in g)g[c](h)&&i.push(g[h]);o.splice.apply(o,i)}for(k=0,l=o.length;k<l;k++){g=o[k];while(g.n){if(b){if(g.f){for(m=0,n=g.f.length;m<n;m++)if(g.f[m]==b){g.f.splice(m,1);break}!g.f.length&&delete g.f}for(h in g.n)if(g.n[c](h)&&g.n[h].f){var p=g.n[h].f;for(m=0,n=p.length;m<n;m++)if(p[m]==b){p.splice(m,1);break}!p.length&&delete g.n[h].f}}else{delete g.f;for(h in g.n)g.n[c](h)&&g.n[h].f&&delete g.n[h].f}g=g.n}}},k.once=function(a,b){var c=function(){var d=b.apply(this,arguments);k.unbind(a,c);return d};return k.on(a,c)},k.version=b,k.toString=function(){return"You are running Eve "+b},typeof module!="undefined"&&module.exports?module.exports=k:typeof define!="undefined"?define("eve",[],function(){return k}):a.eve=k})(this),function(){function cF(a){for(var b=0;b<cy.length;b++)cy[b].el.paper==a&&cy.splice(b--,1)}function cE(b,d,e,f,h,i){e=Q(e);var j,k,l,m=[],o,p,q,t=b.ms,u={},v={},w={};if(f)for(y=0,z=cy.length;y<z;y++){var x=cy[y];if(x.el.id==d.id&&x.anim==b){x.percent!=e?(cy.splice(y,1),l=1):k=x,d.attr(x.totalOrigin);break}}else f=+v;for(var y=0,z=b.percents.length;y<z;y++){if(b.percents[y]==e||b.percents[y]>f*b.top){e=b.percents[y],p=b.percents[y-1]||0,t=t/b.top*(e-p),o=b.percents[y+1],j=b.anim[e];break}f&&d.attr(b.anim[b.percents[y]])}if(!!j){if(!k){for(var A in j)if(j[g](A))if(U[g](A)||d.paper.customAttributes[g](A)){u[A]=d.attr(A),u[A]==null&&(u[A]=T[A]),v[A]=j[A];switch(U[A]){case C:w[A]=(v[A]-u[A])/t;break;case"colour":u[A]=a.getRGB(u[A]);var B=a.getRGB(v[A]);w[A]={r:(B.r-u[A].r)/t,g:(B.g-u[A].g)/t,b:(B.b-u[A].b)/t};break;case"path":var D=bR(u[A],v[A]),E=D[1];u[A]=D[0],w[A]=[];for(y=0,z=u[A].length;y<z;y++){w[A][y]=[0];for(var F=1,G=u[A][y].length;F<G;F++)w[A][y][F]=(E[y][F]-u[A][y][F])/t}break;case"transform":var H=d._,I=ca(H[A],v[A]);if(I){u[A]=I.from,v[A]=I.to,w[A]=[],w[A].real=!0;for(y=0,z=u[A].length;y<z;y++){w[A][y]=[u[A][y][0]];for(F=1,G=u[A][y].length;F<G;F++)w[A][y][F]=(v[A][y][F]-u[A][y][F])/t}}else{var J=d.matrix||new cb,K={_:{transform:H.transform},getBBox:function(){return d.getBBox(1)}};u[A]=[J.a,J.b,J.c,J.d,J.e,J.f],b$(K,v[A]),v[A]=K._.transform,w[A]=[(K.matrix.a-J.a)/t,(K.matrix.b-J.b)/t,(K.matrix.c-J.c)/t,(K.matrix.d-J.d)/t,(K.matrix.e-J.e)/t,(K.matrix.f-J.f)/t]}break;case"csv":var L=r(j[A])[s](c),M=r(u[A])[s](c);if(A=="clip-rect"){u[A]=M,w[A]=[],y=M.length;while(y--)w[A][y]=(L[y]-u[A][y])/t}v[A]=L;break;default:L=[][n](j[A]),M=[][n](u[A]),w[A]=[],y=d.paper.customAttributes[A].length;while(y--)w[A][y]=((L[y]||0)-(M[y]||0))/t}}var O=j.easing,P=a.easing_formulas[O];if(!P){P=r(O).match(N);if(P&&P.length==5){var R=P;P=function(a){return cC(a,+R[1],+R[2],+R[3],+R[4],t)}}else P=bf}q=j.start||b.start||+(new Date),x={anim:b,percent:e,timestamp:q,start:q+(b.del||0),status:0,initstatus:f||0,stop:!1,ms:t,easing:P,from:u,diff:w,to:v,el:d,callback:j.callback,prev:p,next:o,repeat:i||b.times,origin:d.attr(),totalOrigin:h},cy.push(x);if(f&&!k&&!l){x.stop=!0,x.start=new Date-t*f;if(cy.length==1)return cA()}l&&(x.start=new Date-x.ms*f),cy.length==1&&cz(cA)}else k.initstatus=f,k.start=new Date-k.ms*f;eve("raphael.anim.start."+d.id,d,b)}}function cD(a,b){var c=[],d={};this.ms=b,this.times=1;if(a){for(var e in a)a[g](e)&&(d[Q(e)]=a[e],c.push(Q(e)));c.sort(bd)}this.anim=d,this.top=c[c.length-1],this.percents=c}function cC(a,b,c,d,e,f){function o(a,b){var c,d,e,f,j,k;for(e=a,k=0;k<8;k++){f=m(e)-a;if(z(f)<b)return e;j=(3*i*e+2*h)*e+g;if(z(j)<1e-6)break;e=e-f/j}c=0,d=1,e=a;if(e<c)return c;if(e>d)return d;while(c<d){f=m(e);if(z(f-a)<b)return e;a>f?c=e:d=e,e=(d-c)/2+c}return e}function n(a,b){var c=o(a,b);return((l*c+k)*c+j)*c}function m(a){return((i*a+h)*a+g)*a}var g=3*b,h=3*(d-b)-g,i=1-g-h,j=3*c,k=3*(e-c)-j,l=1-j-k;return n(a,1/(200*f))}function cq(){return this.x+q+this.y+q+this.width+" × "+this.height}function cp(){return this.x+q+this.y}function cb(a,b,c,d,e,f){a!=null?(this.a=+a,this.b=+b,this.c=+c,this.d=+d,this.e=+e,this.f=+f):(this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0)}function bH(b,c,d){b=a._path2curve(b),c=a._path2curve(c);var e,f,g,h,i,j,k,l,m,n,o=d?0:[];for(var p=0,q=b.length;p<q;p++){var r=b[p];if(r[0]=="M")e=i=r[1],f=j=r[2];else{r[0]=="C"?(m=[e,f].concat(r.slice(1)),e=m[6],f=m[7]):(m=[e,f,e,f,i,j,i,j],e=i,f=j);for(var s=0,t=c.length;s<t;s++){var u=c[s];if(u[0]=="M")g=k=u[1],h=l=u[2];else{u[0]=="C"?(n=[g,h].concat(u.slice(1)),g=n[6],h=n[7]):(n=[g,h,g,h,k,l,k,l],g=k,h=l);var v=bG(m,n,d);if(d)o+=v;else{for(var w=0,x=v.length;w<x;w++)v[w].segment1=p,v[w].segment2=s,v[w].bez1=m,v[w].bez2=n;o=o.concat(v)}}}}}return o}function bG(b,c,d){var e=a.bezierBBox(b),f=a.bezierBBox(c);if(!a.isBBoxIntersect(e,f))return d?0:[];var g=bB.apply(0,b),h=bB.apply(0,c),i=~~(g/5),j=~~(h/5),k=[],l=[],m={},n=d?0:[];for(var o=0;o<i+1;o++){var p=a.findDotsAtSegment.apply(a,b.concat(o/i));k.push({x:p.x,y:p.y,t:o/i})}for(o=0;o<j+1;o++)p=a.findDotsAtSegment.apply(a,c.concat(o/j)),l.push({x:p.x,y:p.y,t:o/j});for(o=0;o<i;o++)for(var q=0;q<j;q++){var r=k[o],s=k[o+1],t=l[q],u=l[q+1],v=z(s.x-r.x)<.001?"y":"x",w=z(u.x-t.x)<.001?"y":"x",x=bD(r.x,r.y,s.x,s.y,t.x,t.y,u.x,u.y);if(x){if(m[x.x.toFixed(4)]==x.y.toFixed(4))continue;m[x.x.toFixed(4)]=x.y.toFixed(4);var y=r.t+z((x[v]-r[v])/(s[v]-r[v]))*(s.t-r.t),A=t.t+z((x[w]-t[w])/(u[w]-t[w]))*(u.t-t.t);y>=0&&y<=1&&A>=0&&A<=1&&(d?n++:n.push({x:x.x,y:x.y,t1:y,t2:A}))}}return n}function bF(a,b){return bG(a,b,1)}function bE(a,b){return bG(a,b)}function bD(a,b,c,d,e,f,g,h){if(!(x(a,c)<y(e,g)||y(a,c)>x(e,g)||x(b,d)<y(f,h)||y(b,d)>x(f,h))){var i=(a*d-b*c)*(e-g)-(a-c)*(e*h-f*g),j=(a*d-b*c)*(f-h)-(b-d)*(e*h-f*g),k=(a-c)*(f-h)-(b-d)*(e-g);if(!k)return;var l=i/k,m=j/k,n=+l.toFixed(2),o=+m.toFixed(2);if(n<+y(a,c).toFixed(2)||n>+x(a,c).toFixed(2)||n<+y(e,g).toFixed(2)||n>+x(e,g).toFixed(2)||o<+y(b,d).toFixed(2)||o>+x(b,d).toFixed(2)||o<+y(f,h).toFixed(2)||o>+x(f,h).toFixed(2))return;return{x:l,y:m}}}function bC(a,b,c,d,e,f,g,h,i){if(!(i<0||bB(a,b,c,d,e,f,g,h)<i)){var j=1,k=j/2,l=j-k,m,n=.01;m=bB(a,b,c,d,e,f,g,h,l);while(z(m-i)>n)k/=2,l+=(m<i?1:-1)*k,m=bB(a,b,c,d,e,f,g,h,l);return l}}function bB(a,b,c,d,e,f,g,h,i){i==null&&(i=1),i=i>1?1:i<0?0:i;var j=i/2,k=12,l=[-0.1252,.1252,-0.3678,.3678,-0.5873,.5873,-0.7699,.7699,-0.9041,.9041,-0.9816,.9816],m=[.2491,.2491,.2335,.2335,.2032,.2032,.1601,.1601,.1069,.1069,.0472,.0472],n=0;for(var o=0;o<k;o++){var p=j*l[o]+j,q=bA(p,a,c,e,g),r=bA(p,b,d,f,h),s=q*q+r*r;n+=m[o]*w.sqrt(s)}return j*n}function bA(a,b,c,d,e){var f=-3*b+9*c-9*d+3*e,g=a*f+6*b-12*c+6*d;return a*g-3*b+3*c}function by(a,b){var c=[];for(var d=0,e=a.length;e-2*!b>d;d+=2){var f=[{x:+a[d-2],y:+a[d-1]},{x:+a[d],y:+a[d+1]},{x:+a[d+2],y:+a[d+3]},{x:+a[d+4],y:+a[d+5]}];b?d?e-4==d?f[3]={x:+a[0],y:+a[1]}:e-2==d&&(f[2]={x:+a[0],y:+a[1]},f[3]={x:+a[2],y:+a[3]}):f[0]={x:+a[e-2],y:+a[e-1]}:e-4==d?f[3]=f[2]:d||(f[0]={x:+a[d],y:+a[d+1]}),c.push(["C",(-f[0].x+6*f[1].x+f[2].x)/6,(-f[0].y+6*f[1].y+f[2].y)/6,(f[1].x+6*f[2].x-f[3].x)/6,(f[1].y+6*f[2].y-f[3].y)/6,f[2].x,f[2].y])}return c}function bx(){return this.hex}function bv(a,b,c){function d(){var e=Array.prototype.slice.call(arguments,0),f=e.join("␀"),h=d.cache=d.cache||{},i=d.count=d.count||[];if(h[g](f)){bu(i,f);return c?c(h[f]):h[f]}i.length>=1e3&&delete h[i.shift()],i.push(f),h[f]=a[m](b,e);return c?c(h[f]):h[f]}return d}function bu(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return a.push(a.splice(c,1)[0])}function bm(a){if(Object(a)!==a)return a;var b=new a.constructor;for(var c in a)a[g](c)&&(b[c]=bm(a[c]));return b}function a(c){if(a.is(c,"function"))return b?c():eve.on("raphael.DOMload",c);if(a.is(c,E))return a._engine.create[m](a,c.splice(0,3+a.is(c[0],C))).add(c);var d=Array.prototype.slice.call(arguments,0);if(a.is(d[d.length-1],"function")){var e=d.pop();return b?e.call(a._engine.create[m](a,d)):eve.on("raphael.DOMload",function(){e.call(a._engine.create[m](a,d))})}return a._engine.create[m](a,arguments)}a.version="2.1.0",a.eve=eve;var b,c=/[, ]+/,d={circle:1,rect:1,path:1,ellipse:1,text:1,image:1},e=/\{(\d+)\}/g,f="prototype",g="hasOwnProperty",h={doc:document,win:window},i={was:Object.prototype[g].call(h.win,"Raphael"),is:h.win.Raphael},j=function(){this.ca=this.customAttributes={}},k,l="appendChild",m="apply",n="concat",o="createTouch"in h.doc,p="",q=" ",r=String,s="split",t="click dblclick mousedown mousemove mouseout mouseover mouseup touchstart touchmove touchend touchcancel"[s](q),u={mousedown:"touchstart",mousemove:"touchmove",mouseup:"touchend"},v=r.prototype.toLowerCase,w=Math,x=w.max,y=w.min,z=w.abs,A=w.pow,B=w.PI,C="number",D="string",E="array",F="toString",G="fill",H=Object.prototype.toString,I={},J="push",K=a._ISURL=/^url\(['"]?([^\)]+?)['"]?\)$/i,L=/^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\))\s*$/i,M={NaN:1,Infinity:1,"-Infinity":1},N=/^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/,O=w.round,P="setAttribute",Q=parseFloat,R=parseInt,S=r.prototype.toUpperCase,T=a._availableAttrs={"arrow-end":"none","arrow-start":"none",blur:0,"clip-rect":"0 0 1e9 1e9",cursor:"default",cx:0,cy:0,fill:"#fff","fill-opacity":1,font:'10px "Arial"',"font-family":'"Arial"',"font-size":"10","font-style":"normal","font-weight":400,gradient:0,height:0,href:"http://raphaeljs.com/","letter-spacing":0,opacity:1,path:"M0,0",r:0,rx:0,ry:0,src:"",stroke:"#000","stroke-dasharray":"","stroke-linecap":"butt","stroke-linejoin":"butt","stroke-miterlimit":0,"stroke-opacity":1,"stroke-width":1,target:"_blank","text-anchor":"middle",title:"Raphael",transform:"",width:0,x:0,y:0},U=a._availableAnimAttrs={blur:C,"clip-rect":"csv",cx:C,cy:C,fill:"colour","fill-opacity":C,"font-size":C,height:C,opacity:C,path:"path",r:C,rx:C,ry:C,stroke:"colour","stroke-opacity":C,"stroke-width":C,transform:"transform",width:C,x:C,y:C},V=/[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]/g,W=/[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*/,X={hs:1,rg:1},Y=/,?([achlmqrstvxz]),?/gi,Z=/([achlmrqstvz])[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*)+)/ig,$=/([rstm])[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*)+)/ig,_=/(-?\d*\.?\d*(?:e[\-+]?\d+)?)[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*/ig,ba=a._radial_gradient=/^r(?:\(([^,]+?)[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*([^\)]+?)\))?/,bb={},bc=function(a,b){return a.key-b.key},bd=function(a,b){return Q(a)-Q(b)},be=function(){},bf=function(a){return a},bg=a._rectPath=function(a,b,c,d,e){if(e)return[["M",a+e,b],["l",c-e*2,0],["a",e,e,0,0,1,e,e],["l",0,d-e*2],["a",e,e,0,0,1,-e,e],["l",e*2-c,0],["a",e,e,0,0,1,-e,-e],["l",0,e*2-d],["a",e,e,0,0,1,e,-e],["z"]];return[["M",a,b],["l",c,0],["l",0,d],["l",-c,0],["z"]]},bh=function(a,b,c,d){d==null&&(d=c);return[["M",a,b],["m",0,-d],["a",c,d,0,1,1,0,2*d],["a",c,d,0,1,1,0,-2*d],["z"]]},bi=a._getPath={path:function(a){return a.attr("path")},circle:function(a){var b=a.attrs;return bh(b.cx,b.cy,b.r)},ellipse:function(a){var b=a.attrs;return bh(b.cx,b.cy,b.rx,b.ry)},rect:function(a){var b=a.attrs;return bg(b.x,b.y,b.width,b.height,b.r)},image:function(a){var b=a.attrs;return bg(b.x,b.y,b.width,b.height)},text:function(a){var b=a._getBBox();return bg(b.x,b.y,b.width,b.height)}},bj=a.mapPath=function(a,b){if(!b)return a;var c,d,e,f,g,h,i;a=bR(a);for(e=0,g=a.length;e<g;e++){i=a[e];for(f=1,h=i.length;f<h;f+=2)c=b.x(i[f],i[f+1]),d=b.y(i[f],i[f+1]),i[f]=c,i[f+1]=d}return a};a._g=h,a.type=h.win.SVGAngle||h.doc.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure","1.1")?"SVG":"VML";if(a.type=="VML"){var bk=h.doc.createElement("div"),bl;bk.innerHTML='<v:shape adj="1"/>',bl=bk.firstChild,bl.style.behavior="url(#default#VML)";if(!bl||typeof bl.adj!="object")return a.type=p;bk=null}a.svg=!(a.vml=a.type=="VML"),a._Paper=j,a.fn=k=j.prototype=a.prototype,a._id=0,a._oid=0,a.is=function(a,b){b=v.call(b);if(b=="finite")return!M[g](+a);if(b=="array")return a instanceof Array;return b=="null"&&a===null||b==typeof a&&a!==null||b=="object"&&a===Object(a)||b=="array"&&Array.isArray&&Array.isArray(a)||H.call(a).slice(8,-1).toLowerCase()==b},a.angle=function(b,c,d,e,f,g){if(f==null){var h=b-d,i=c-e;if(!h&&!i)return 0;return(180+w.atan2(-i,-h)*180/B+360)%360}return a.angle(b,c,f,g)-a.angle(d,e,f,g)},a.rad=function(a){return a%360*B/180},a.deg=function(a){return a*180/B%360},a.snapTo=function(b,c,d){d=a.is(d,"finite")?d:10;if(a.is(b,E)){var e=b.length;while(e--)if(z(b[e]-c)<=d)return b[e]}else{b=+b;var f=c%b;if(f<d)return c-f;if(f>b-d)return c-f+b}return c};var bn=a.createUUID=function(a,b){return function(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(a,b).toUpperCase()}}(/[xy]/g,function(a){var b=w.random()*16|0,c=a=="x"?b:b&3|8;return c.toString(16)});a.setWindow=function(b){eve("raphael.setWindow",a,h.win,b),h.win=b,h.doc=h.win.document,a._engine.initWin&&a._engine.initWin(h.win)};var bo=function(b){if(a.vml){var c=/^\s+|\s+$/g,d;try{var e=new ActiveXObject("htmlfile");e.write("<body>"),e.close(),d=e.body}catch(f){d=createPopup().document.body}var g=d.createTextRange();bo=bv(function(a){try{d.style.color=r(a).replace(c,p);var b=g.queryCommandValue("ForeColor");b=(b&255)<<16|b&65280|(b&16711680)>>>16;return"#"+("000000"+b.toString(16)).slice(-6)}catch(e){return"none"}})}else{var i=h.doc.createElement("i");i.title="Raphaël Colour Picker",i.style.display="none",h.doc.body.appendChild(i),bo=bv(function(a){i.style.color=a;return h.doc.defaultView.getComputedStyle(i,p).getPropertyValue("color")})}return bo(b)},bp=function(){return"hsb("+[this.h,this.s,this.b]+")"},bq=function(){return"hsl("+[this.h,this.s,this.l]+")"},br=function(){return this.hex},bs=function(b,c,d){c==null&&a.is(b,"object")&&"r"in b&&"g"in b&&"b"in b&&(d=b.b,c=b.g,b=b.r);if(c==null&&a.is(b,D)){var e=a.getRGB(b);b=e.r,c=e.g,d=e.b}if(b>1||c>1||d>1)b/=255,c/=255,d/=255;return[b,c,d]},bt=function(b,c,d,e){b*=255,c*=255,d*=255;var f={r:b,g:c,b:d,hex:a.rgb(b,c,d),toString:br};a.is(e,"finite")&&(f.opacity=e);return f};a.color=function(b){var c;a.is(b,"object")&&"h"in b&&"s"in b&&"b"in b?(c=a.hsb2rgb(b),b.r=c.r,b.g=c.g,b.b=c.b,b.hex=c.hex):a.is(b,"object")&&"h"in b&&"s"in b&&"l"in b?(c=a.hsl2rgb(b),b.r=c.r,b.g=c.g,b.b=c.b,b.hex=c.hex):(a.is(b,"string")&&(b=a.getRGB(b)),a.is(b,"object")&&"r"in b&&"g"in b&&"b"in b?(c=a.rgb2hsl(b),b.h=c.h,b.s=c.s,b.l=c.l,c=a.rgb2hsb(b),b.v=c.b):(b={hex:"none"},b.r=b.g=b.b=b.h=b.s=b.v=b.l=-1)),b.toString=br;return b},a.hsb2rgb=function(a,b,c,d){this.is(a,"object")&&"h"in a&&"s"in a&&"b"in a&&(c=a.b,b=a.s,a=a.h,d=a.o),a*=360;var e,f,g,h,i;a=a%360/60,i=c*b,h=i*(1-z(a%2-1)),e=f=g=c-i,a=~~a,e+=[i,h,0,0,h,i][a],f+=[h,i,i,h,0,0][a],g+=[0,0,h,i,i,h][a];return bt(e,f,g,d)},a.hsl2rgb=function(a,b,c,d){this.is(a,"object")&&"h"in a&&"s"in a&&"l"in a&&(c=a.l,b=a.s,a=a.h);if(a>1||b>1||c>1)a/=360,b/=100,c/=100;a*=360;var e,f,g,h,i;a=a%360/60,i=2*b*(c<.5?c:1-c),h=i*(1-z(a%2-1)),e=f=g=c-i/2,a=~~a,e+=[i,h,0,0,h,i][a],f+=[h,i,i,h,0,0][a],g+=[0,0,h,i,i,h][a];return bt(e,f,g,d)},a.rgb2hsb=function(a,b,c){c=bs(a,b,c),a=c[0],b=c[1],c=c[2];var d,e,f,g;f=x(a,b,c),g=f-y(a,b,c),d=g==0?null:f==a?(b-c)/g:f==b?(c-a)/g+2:(a-b)/g+4,d=(d+360)%6*60/360,e=g==0?0:g/f;return{h:d,s:e,b:f,toString:bp}},a.rgb2hsl=function(a,b,c){c=bs(a,b,c),a=c[0],b=c[1],c=c[2];var d,e,f,g,h,i;g=x(a,b,c),h=y(a,b,c),i=g-h,d=i==0?null:g==a?(b-c)/i:g==b?(c-a)/i+2:(a-b)/i+4,d=(d+360)%6*60/360,f=(g+h)/2,e=i==0?0:f<.5?i/(2*f):i/(2-2*f);return{h:d,s:e,l:f,toString:bq}},a._path2string=function(){return this.join(",").replace(Y,"$1")};var bw=a._preload=function(a,b){var c=h.doc.createElement("img");c.style.cssText="position:absolute;left:-9999em;top:-9999em",c.onload=function(){b.call(this),this.onload=null,h.doc.body.removeChild(this)},c.onerror=function(){h.doc.body.removeChild(this)},h.doc.body.appendChild(c),c.src=a};a.getRGB=bv(function(b){if(!b||!!((b=r(b)).indexOf("-")+1))return{r:-1,g:-1,b:-1,hex:"none",error:1,toString:bx};if(b=="none")return{r:-1,g:-1,b:-1,hex:"none",toString:bx};!X[g](b.toLowerCase().substring(0,2))&&b.charAt()!="#"&&(b=bo(b));var c,d,e,f,h,i,j,k=b.match(L);if(k){k[2]&&(f=R(k[2].substring(5),16),e=R(k[2].substring(3,5),16),d=R(k[2].substring(1,3),16)),k[3]&&(f=R((i=k[3].charAt(3))+i,16),e=R((i=k[3].charAt(2))+i,16),d=R((i=k[3].charAt(1))+i,16)),k[4]&&(j=k[4][s](W),d=Q(j[0]),j[0].slice(-1)=="%"&&(d*=2.55),e=Q(j[1]),j[1].slice(-1)=="%"&&(e*=2.55),f=Q(j[2]),j[2].slice(-1)=="%"&&(f*=2.55),k[1].toLowerCase().slice(0,4)=="rgba"&&(h=Q(j[3])),j[3]&&j[3].slice(-1)=="%"&&(h/=100));if(k[5]){j=k[5][s](W),d=Q(j[0]),j[0].slice(-1)=="%"&&(d*=2.55),e=Q(j[1]),j[1].slice(-1)=="%"&&(e*=2.55),f=Q(j[2]),j[2].slice(-1)=="%"&&(f*=2.55),(j[0].slice(-3)=="deg"||j[0].slice(-1)=="°")&&(d/=360),k[1].toLowerCase().slice(0,4)=="hsba"&&(h=Q(j[3])),j[3]&&j[3].slice(-1)=="%"&&(h/=100);return a.hsb2rgb(d,e,f,h)}if(k[6]){j=k[6][s](W),d=Q(j[0]),j[0].slice(-1)=="%"&&(d*=2.55),e=Q(j[1]),j[1].slice(-1)=="%"&&(e*=2.55),f=Q(j[2]),j[2].slice(-1)=="%"&&(f*=2.55),(j[0].slice(-3)=="deg"||j[0].slice(-1)=="°")&&(d/=360),k[1].toLowerCase().slice(0,4)=="hsla"&&(h=Q(j[3])),j[3]&&j[3].slice(-1)=="%"&&(h/=100);return a.hsl2rgb(d,e,f,h)}k={r:d,g:e,b:f,toString:bx},k.hex="#"+(16777216|f|e<<8|d<<16).toString(16).slice(1),a.is(h,"finite")&&(k.opacity=h);return k}return{r:-1,g:-1,b:-1,hex:"none",error:1,toString:bx}},a),a.hsb=bv(function(b,c,d){return a.hsb2rgb(b,c,d).hex}),a.hsl=bv(function(b,c,d){return a.hsl2rgb(b,c,d).hex}),a.rgb=bv(function(a,b,c){return"#"+(16777216|c|b<<8|a<<16).toString(16).slice(1)}),a.getColor=function(a){var b=this.getColor.start=this.getColor.start||{h:0,s:1,b:a||.75},c=this.hsb2rgb(b.h,b.s,b.b);b.h+=.075,b.h>1&&(b.h=0,b.s-=.2,b.s<=0&&(this.getColor.start={h:0,s:1,b:b.b}));return c.hex},a.getColor.reset=function(){delete this.start},a.parsePathString=function(b){if(!b)return null;var c=bz(b);if(c.arr)return bJ(c.arr);var d={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},e=[];a.is(b,E)&&a.is(b[0],E)&&(e=bJ(b)),e.length||r(b).replace(Z,function(a,b,c){var f=[],g=b.toLowerCase();c.replace(_,function(a,b){b&&f.push(+b)}),g=="m"&&f.length>2&&(e.push([b][n](f.splice(0,2))),g="l",b=b=="m"?"l":"L");if(g=="r")e.push([b][n](f));else while(f.length>=d[g]){e.push([b][n](f.splice(0,d[g])));if(!d[g])break}}),e.toString=a._path2string,c.arr=bJ(e);return e},a.parseTransformString=bv(function(b){if(!b)return null;var c={r:3,s:4,t:2,m:6},d=[];a.is(b,E)&&a.is(b[0],E)&&(d=bJ(b)),d.length||r(b).replace($,function(a,b,c){var e=[],f=v.call(b);c.replace(_,function(a,b){b&&e.push(+b)}),d.push([b][n](e))}),d.toString=a._path2string;return d});var bz=function(a){var b=bz.ps=bz.ps||{};b[a]?b[a].sleep=100:b[a]={sleep:100},setTimeout(function(){for(var c in b)b[g](c)&&c!=a&&(b[c].sleep--,!b[c].sleep&&delete b[c])});return b[a]};a.findDotsAtSegment=function(a,b,c,d,e,f,g,h,i){var j=1-i,k=A(j,3),l=A(j,2),m=i*i,n=m*i,o=k*a+l*3*i*c+j*3*i*i*e+n*g,p=k*b+l*3*i*d+j*3*i*i*f+n*h,q=a+2*i*(c-a)+m*(e-2*c+a),r=b+2*i*(d-b)+m*(f-2*d+b),s=c+2*i*(e-c)+m*(g-2*e+c),t=d+2*i*(f-d)+m*(h-2*f+d),u=j*a+i*c,v=j*b+i*d,x=j*e+i*g,y=j*f+i*h,z=90-w.atan2(q-s,r-t)*180/B;(q>s||r<t)&&(z+=180);return{x:o,y:p,m:{x:q,y:r},n:{x:s,y:t},start:{x:u,y:v},end:{x:x,y:y},alpha:z}},a.bezierBBox=function(b,c,d,e,f,g,h,i){a.is(b,"array")||(b=[b,c,d,e,f,g,h,i]);var j=bQ.apply(null,b);return{x:j.min.x,y:j.min.y,x2:j.max.x,y2:j.max.y,width:j.max.x-j.min.x,height:j.max.y-j.min.y}},a.isPointInsideBBox=function(a,b,c){return b>=a.x&&b<=a.x2&&c>=a.y&&c<=a.y2},a.isBBoxIntersect=function(b,c){var d=a.isPointInsideBBox;return d(c,b.x,b.y)||d(c,b.x2,b.y)||d(c,b.x,b.y2)||d(c,b.x2,b.y2)||d(b,c.x,c.y)||d(b,c.x2,c.y)||d(b,c.x,c.y2)||d(b,c.x2,c.y2)||(b.x<c.x2&&b.x>c.x||c.x<b.x2&&c.x>b.x)&&(b.y<c.y2&&b.y>c.y||c.y<b.y2&&c.y>b.y)},a.pathIntersection=function(a,b){return bH(a,b)},a.pathIntersectionNumber=function(a,b){return bH(a,b,1)},a.isPointInsidePath=function(b,c,d){var e=a.pathBBox(b);return a.isPointInsideBBox(e,c,d)&&bH(b,[["M",c,d],["H",e.x2+10]],1)%2==1},a._removedFactory=function(a){return function(){eve("raphael.log",null,"Raphaël: you are calling to method “"+a+"” of removed object",a)}};var bI=a.pathBBox=function(a){var b=bz(a);if(b.bbox)return b.bbox;if(!a)return{x:0,y:0,width:0,height:0,x2:0,y2:0};a=bR(a);var c=0,d=0,e=[],f=[],g;for(var h=0,i=a.length;h<i;h++){g=a[h];if(g[0]=="M")c=g[1],d=g[2],e.push(c),f.push(d);else{var j=bQ(c,d,g[1],g[2],g[3],g[4],g[5],g[6]);e=e[n](j.min.x,j.max.x),f=f[n](j.min.y,j.max.y),c=g[5],d=g[6]}}var k=y[m](0,e),l=y[m](0,f),o=x[m](0,e),p=x[m](0,f),q={x:k,y:l,x2:o,y2:p,width:o-k,height:p-l};b.bbox=bm(q);return q},bJ=function(b){var c=bm(b);c.toString=a._path2string;return c},bK=a._pathToRelative=function(b){var c=bz(b);if(c.rel)return bJ(c.rel);if(!a.is(b,E)||!a.is(b&&b[0],E))b=a.parsePathString(b);var d=[],e=0,f=0,g=0,h=0,i=0;b[0][0]=="M"&&(e=b[0][1],f=b[0][2],g=e,h=f,i++,d.push(["M",e,f]));for(var j=i,k=b.length;j<k;j++){var l=d[j]=[],m=b[j];if(m[0]!=v.call(m[0])){l[0]=v.call(m[0]);switch(l[0]){case"a":l[1]=m[1],l[2]=m[2],l[3]=m[3],l[4]=m[4],l[5]=m[5],l[6]=+(m[6]-e).toFixed(3),l[7]=+(m[7]-f).toFixed(3);break;case"v":l[1]=+(m[1]-f).toFixed(3);break;case"m":g=m[1],h=m[2];default:for(var n=1,o=m.length;n<o;n++)l[n]=+(m[n]-(n%2?e:f)).toFixed(3)}}else{l=d[j]=[],m[0]=="m"&&(g=m[1]+e,h=m[2]+f);for(var p=0,q=m.length;p<q;p++)d[j][p]=m[p]}var r=d[j].length;switch(d[j][0]){case"z":e=g,f=h;break;case"h":e+=+d[j][r-1];break;case"v":f+=+d[j][r-1];break;default:e+=+d[j][r-2],f+=+d[j][r-1]}}d.toString=a._path2string,c.rel=bJ(d);return d},bL=a._pathToAbsolute=function(b){var c=bz(b);if(c.abs)return bJ(c.abs);if(!a.is(b,E)||!a.is(b&&b[0],E))b=a.parsePathString(b);if(!b||!b.length)return[["M",0,0]];var d=[],e=0,f=0,g=0,h=0,i=0;b[0][0]=="M"&&(e=+b[0][1],f=+b[0][2],g=e,h=f,i++,d[0]=["M",e,f]);var j=b.length==3&&b[0][0]=="M"&&b[1][0].toUpperCase()=="R"&&b[2][0].toUpperCase()=="Z";for(var k,l,m=i,o=b.length;m<o;m++){d.push(k=[]),l=b[m];if(l[0]!=S.call(l[0])){k[0]=S.call(l[0]);switch(k[0]){case"A":k[1]=l[1],k[2]=l[2],k[3]=l[3],k[4]=l[4],k[5]=l[5],k[6]=+(l[6]+e),k[7]=+(l[7]+f);break;case"V":k[1]=+l[1]+f;break;case"H":k[1]=+l[1]+e;break;case"R":var p=[e,f][n](l.slice(1));for(var q=2,r=p.length;q<r;q++)p[q]=+p[q]+e,p[++q]=+p[q]+f;d.pop(),d=d[n](by(p,j));break;case"M":g=+l[1]+e,h=+l[2]+f;default:for(q=1,r=l.length;q<r;q++)k[q]=+l[q]+(q%2?e:f)}}else if(l[0]=="R")p=[e,f][n](l.slice(1)),d.pop(),d=d[n](by(p,j)),k=["R"][n](l.slice(-2));else for(var s=0,t=l.length;s<t;s++)k[s]=l[s];switch(k[0]){case"Z":e=g,f=h;break;case"H":e=k[1];break;case"V":f=k[1];break;case"M":g=k[k.length-2],h=k[k.length-1];default:e=k[k.length-2],f=k[k.length-1]}}d.toString=a._path2string,c.abs=bJ(d);return d},bM=function(a,b,c,d){return[a,b,c,d,c,d]},bN=function(a,b,c,d,e,f){var g=1/3,h=2/3;return[g*a+h*c,g*b+h*d,g*e+h*c,g*f+h*d,e,f]},bO=function(a,b,c,d,e,f,g,h,i,j){var k=B*120/180,l=B/180*(+e||0),m=[],o,p=bv(function(a,b,c){var d=a*w.cos(c)-b*w.sin(c),e=a*w.sin(c)+b*w.cos(c);return{x:d,y:e}});if(!j){o=p(a,b,-l),a=o.x,b=o.y,o=p(h,i,-l),h=o.x,i=o.y;var q=w.cos(B/180*e),r=w.sin(B/180*e),t=(a-h)/2,u=(b-i)/2,v=t*t/(c*c)+u*u/(d*d);v>1&&(v=w.sqrt(v),c=v*c,d=v*d);var x=c*c,y=d*d,A=(f==g?-1:1)*w.sqrt(z((x*y-x*u*u-y*t*t)/(x*u*u+y*t*t))),C=A*c*u/d+(a+h)/2,D=A*-d*t/c+(b+i)/2,E=w.asin(((b-D)/d).toFixed(9)),F=w.asin(((i-D)/d).toFixed(9));E=a<C?B-E:E,F=h<C?B-F:F,E<0&&(E=B*2+E),F<0&&(F=B*2+F),g&&E>F&&(E=E-B*2),!g&&F>E&&(F=F-B*2)}else E=j[0],F=j[1],C=j[2],D=j[3];var G=F-E;if(z(G)>k){var H=F,I=h,J=i;F=E+k*(g&&F>E?1:-1),h=C+c*w.cos(F),i=D+d*w.sin(F),m=bO(h,i,c,d,e,0,g,I,J,[F,H,C,D])}G=F-E;var K=w.cos(E),L=w.sin(E),M=w.cos(F),N=w.sin(F),O=w.tan(G/4),P=4/3*c*O,Q=4/3*d*O,R=[a,b],S=[a+P*L,b-Q*K],T=[h+P*N,i-Q*M],U=[h,i];S[0]=2*R[0]-S[0],S[1]=2*R[1]-S[1];if(j)return[S,T,U][n](m);m=[S,T,U][n](m).join()[s](",");var V=[];for(var W=0,X=m.length;W<X;W++)V[W]=W%2?p(m[W-1],m[W],l).y:p(m[W],m[W+1],l).x;return V},bP=function(a,b,c,d,e,f,g,h,i){var j=1-i;return{x:A(j,3)*a+A(j,2)*3*i*c+j*3*i*i*e+A(i,3)*g,y:A(j,3)*b+A(j,2)*3*i*d+j*3*i*i*f+A(i,3)*h}},bQ=bv(function(a,b,c,d,e,f,g,h){var i=e-2*c+a-(g-2*e+c),j=2*(c-a)-2*(e-c),k=a-c,l=(-j+w.sqrt(j*j-4*i*k))/2/i,n=(-j-w.sqrt(j*j-4*i*k))/2/i,o=[b,h],p=[a,g],q;z(l)>"1e12"&&(l=.5),z(n)>"1e12"&&(n=.5),l>0&&l<1&&(q=bP(a,b,c,d,e,f,g,h,l),p.push(q.x),o.push(q.y)),n>0&&n<1&&(q=bP(a,b,c,d,e,f,g,h,n),p.push(q.x),o.push(q.y)),i=f-2*d+b-(h-2*f+d),j=2*(d-b)-2*(f-d),k=b-d,l=(-j+w.sqrt(j*j-4*i*k))/2/i,n=(-j-w.sqrt(j*j-4*i*k))/2/i,z(l)>"1e12"&&(l=.5),z(n)>"1e12"&&(n=.5),l>0&&l<1&&(q=bP(a,b,c,d,e,f,g,h,l),p.push(q.x),o.push(q.y)),n>0&&n<1&&(q=bP(a,b,c,d,e,f,g,h,n),p.push(q.x),o.push(q.y));return{min:{x:y[m](0,p),y:y[m](0,o)},max:{x:x[m](0,p),y:x[m](0,o)}}}),bR=a._path2curve=bv(function(a,b){var c=!b&&bz(a);if(!b&&c.curve)return bJ(c.curve);var d=bL(a),e=b&&bL(b),f={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},g={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},h=function(a,b){var c,d;if(!a)return["C",b.x,b.y,b.x,b.y,b.x,b.y];!(a[0]in{T:1,Q:1})&&(b.qx=b.qy=null);switch(a[0]){case"M":b.X=a[1],b.Y=a[2];break;case"A":a=["C"][n](bO[m](0,[b.x,b.y][n](a.slice(1))));break;case"S":c=b.x+(b.x-(b.bx||b.x)),d=b.y+(b.y-(b.by||b.y)),a=["C",c,d][n](a.slice(1));break;case"T":b.qx=b.x+(b.x-(b.qx||b.x)),b.qy=b.y+(b.y-(b.qy||b.y)),a=["C"][n](bN(b.x,b.y,b.qx,b.qy,a[1],a[2]));break;case"Q":b.qx=a[1],b.qy=a[2],a=["C"][n](bN(b.x,b.y,a[1],a[2],a[3],a[4]));break;case"L":a=["C"][n](bM(b.x,b.y,a[1],a[2]));break;case"H":a=["C"][n](bM(b.x,b.y,a[1],b.y));break;case"V":a=["C"][n](bM(b.x,b.y,b.x,a[1]));break;case"Z":a=["C"][n](bM(b.x,b.y,b.X,b.Y))}return a},i=function(a,b){if(a[b].length>7){a[b].shift();var c=a[b];while(c.length)a.splice(b++,0,["C"][n](c.splice(0,6)));a.splice(b,1),l=x(d.length,e&&e.length||0)}},j=function(a,b,c,f,g){a&&b&&a[g][0]=="M"&&b[g][0]!="M"&&(b.splice(g,0,["M",f.x,f.y]),c.bx=0,c.by=0,c.x=a[g][1],c.y=a[g][2],l=x(d.length,e&&e.length||0))};for(var k=0,l=x(d.length,e&&e.length||0);k<l;k++){d[k]=h(d[k],f),i(d,k),e&&(e[k]=h(e[k],g)),e&&i(e,k),j(d,e,f,g,k),j(e,d,g,f,k);var o=d[k],p=e&&e[k],q=o.length,r=e&&p.length;f.x=o[q-2],f.y=o[q-1],f.bx=Q(o[q-4])||f.x,f.by=Q(o[q-3])||f.y,g.bx=e&&(Q(p[r-4])||g.x),g.by=e&&(Q(p[r-3])||g.y),g.x=e&&p[r-2],g.y=e&&p[r-1]}e||(c.curve=bJ(d));return e?[d,e]:d},null,bJ),bS=a._parseDots=bv(function(b){var c=[];for(var d=0,e=b.length;d<e;d++){var f={},g=b[d].match(/^([^:]*):?([\d\.]*)/);f.color=a.getRGB(g[1]);if(f.color.error)return null;f.color=f.color.hex,g[2]&&(f.offset=g[2]+"%"),c.push(f)}for(d=1,e=c.length-1;d<e;d++)if(!c[d].offset){var h=Q(c[d-1].offset||0),i=0;for(var j=d+1;j<e;j++)if(c[j].offset){i=c[j].offset;break}i||(i=100,j=e),i=Q(i);var k=(i-h)/(j-d+1);for(;d<j;d++)h+=k,c[d].offset=h+"%"}return c}),bT=a._tear=function(a,b){a==b.top&&(b.top=a.prev),a==b.bottom&&(b.bottom=a.next),a.next&&(a.next.prev=a.prev),a.prev&&(a.prev.next=a.next)},bU=a._tofront=function(a,b){b.top!==a&&(bT(a,b),a.next=null,a.prev=b.top,b.top.next=a,b.top=a)},bV=a._toback=function(a,b){b.bottom!==a&&(bT(a,b),a.next=b.bottom,a.prev=null,b.bottom.prev=a,b.bottom=a)},bW=a._insertafter=function(a,b,c){bT(a,c),b==c.top&&(c.top=a),b.next&&(b.next.prev=a),a.next=b.next,a.prev=b,b.next=a},bX=a._insertbefore=function(a,b,c){bT(a,c),b==c.bottom&&(c.bottom=a),b.prev&&(b.prev.next=a),a.prev=b.prev,b.prev=a,a.next=b},bY=a.toMatrix=function(a,b){var c=bI(a),d={_:{transform:p},getBBox:function(){return c}};b$(d,b);return d.matrix},bZ=a.transformPath=function(a,b){return bj(a,bY(a,b))},b$=a._extractTransform=function(b,c){if(c==null)return b._.transform;c=r(c).replace(/\.{3}|\u2026/g,b._.transform||p);var d=a.parseTransformString(c),e=0,f=0,g=0,h=1,i=1,j=b._,k=new cb;j.transform=d||[];if(d)for(var l=0,m=d.length;l<m;l++){var n=d[l],o=n.length,q=r(n[0]).toLowerCase(),s=n[0]!=q,t=s?k.invert():0,u,v,w,x,y;q=="t"&&o==3?s?(u=t.x(0,0),v=t.y(0,0),w=t.x(n[1],n[2]),x=t.y(n[1],n[2]),k.translate(w-u,x-v)):k.translate(n[1],n[2]):q=="r"?o==2?(y=y||b.getBBox(1),k.rotate(n[1],y.x+y.width/2,y.y+y.height/2),e+=n[1]):o==4&&(s?(w=t.x(n[2],n[3]),x=t.y(n[2],n[3]),k.rotate(n[1],w,x)):k.rotate(n[1],n[2],n[3]),e+=n[1]):q=="s"?o==2||o==3?(y=y||b.getBBox(1),k.scale(n[1],n[o-1],y.x+y.width/2,y.y+y.height/2),h*=n[1],i*=n[o-1]):o==5&&(s?(w=t.x(n[3],n[4]),x=t.y(n[3],n[4]),k.scale(n[1],n[2],w,x)):k.scale(n[1],n[2],n[3],n[4]),h*=n[1],i*=n[2]):q=="m"&&o==7&&k.add(n[1],n[2],n[3],n[4],n[5],n[6]),j.dirtyT=1,b.matrix=k}b.matrix=k,j.sx=h,j.sy=i,j.deg=e,j.dx=f=k.e,j.dy=g=k.f,h==1&&i==1&&!e&&j.bbox?(j.bbox.x+=+f,j.bbox.y+=+g):j.dirtyT=1},b_=function(a){var b=a[0];switch(b.toLowerCase()){case"t":return[b,0,0];case"m":return[b,1,0,0,1,0,0];case"r":return a.length==4?[b,0,a[2],a[3]]:[b,0];case"s":return a.length==5?[b,1,1,a[3],a[4]]:a.length==3?[b,1,1]:[b,1]}},ca=a._equaliseTransform=function(b,c){c=r(c).replace(/\.{3}|\u2026/g,b),b=a.parseTransformString(b)||[],c=a.parseTransformString(c)||[];var d=x(b.length,c.length),e=[],f=[],g=0,h,i,j,k;for(;g<d;g++){j=b[g]||b_(c[g]),k=c[g]||b_(j);if(j[0]!=k[0]||j[0].toLowerCase()=="r"&&(j[2]!=k[2]||j[3]!=k[3])||j[0].toLowerCase()=="s"&&(j[3]!=k[3]||j[4]!=k[4]))return;e[g]=[],f[g]=[];for(h=0,i=x(j.length,k.length);h<i;h++)h in j&&(e[g][h]=j[h]),h in k&&(f[g][h]=k[h])}return{from:e,to:f}};a._getContainer=function(b,c,d,e){var f;f=e==null&&!a.is(b,"object")?h.doc.getElementById(b):b;if(f!=null){if(f.tagName)return c==null?{container:f,width:f.style.pixelWidth||f.offsetWidth,height:f.style.pixelHeight||f.offsetHeight}:{container:f,width:c,height:d};return{container:1,x:b,y:c,width:d,height:e}}},a.pathToRelative=bK,a._engine={},a.path2curve=bR,a.matrix=function(a,b,c,d,e,f){return new cb(a,b,c,d,e,f)},function(b){function d(a){var b=w.sqrt(c(a));a[0]&&(a[0]/=b),a[1]&&(a[1]/=b)}function c(a){return a[0]*a[0]+a[1]*a[1]}b.add=function(a,b,c,d,e,f){var g=[[],[],[]],h=[[this.a,this.c,this.e],[this.b,this.d,this.f],[0,0,1]],i=[[a,c,e],[b,d,f],[0,0,1]],j,k,l,m;a&&a instanceof cb&&(i=[[a.a,a.c,a.e],[a.b,a.d,a.f],[0,0,1]]);for(j=0;j<3;j++)for(k=0;k<3;k++){m=0;for(l=0;l<3;l++)m+=h[j][l]*i[l][k];g[j][k]=m}this.a=g[0][0],this.b=g[1][0],this.c=g[0][1],this.d=g[1][1],this.e=g[0][2],this.f=g[1][2]},b.invert=function(){var a=this,b=a.a*a.d-a.b*a.c;return new cb(a.d/b,-a.b/b,-a.c/b,a.a/b,(a.c*a.f-a.d*a.e)/b,(a.b*a.e-a.a*a.f)/b)},b.clone=function(){return new cb(this.a,this.b,this.c,this.d,this.e,this.f)},b.translate=function(a,b){this.add(1,0,0,1,a,b)},b.scale=function(a,b,c,d){b==null&&(b=a),(c||d)&&this.add(1,0,0,1,c,d),this.add(a,0,0,b,0,0),(c||d)&&this.add(1,0,0,1,-c,-d)},b.rotate=function(b,c,d){b=a.rad(b),c=c||0,d=d||0;var e=+w.cos(b).toFixed(9),f=+w.sin(b).toFixed(9);this.add(e,f,-f,e,c,d),this.add(1,0,0,1,-c,-d)},b.x=function(a,b){return a*this.a+b*this.c+this.e},b.y=function(a,b){return a*this.b+b*this.d+this.f},b.get=function(a){return+this[r.fromCharCode(97+a)].toFixed(4)},b.toString=function(){return a.svg?"matrix("+[this.get(0),this.get(1),this.get(2),this.get(3),this.get(4),this.get(5)].join()+")":[this.get(0),this.get(2),this.get(1),this.get(3),0,0].join()},b.toFilter=function(){return"progid:DXImageTransform.Microsoft.Matrix(M11="+this.get(0)+", M12="+this.get(2)+", M21="+this.get(1)+", M22="+this.get(3)+", Dx="+this.get(4)+", Dy="+this.get(5)+", sizingmethod='auto expand')"},b.offset=function(){return[this.e.toFixed(4),this.f.toFixed(4)]},b.split=function(){var b={};b.dx=this.e,b.dy=this.f;var e=[[this.a,this.c],[this.b,this.d]];b.scalex=w.sqrt(c(e[0])),d(e[0]),b.shear=e[0][0]*e[1][0]+e[0][1]*e[1][1],e[1]=[e[1][0]-e[0][0]*b.shear,e[1][1]-e[0][1]*b.shear],b.scaley=w.sqrt(c(e[1])),d(e[1]),b.shear/=b.scaley;var f=-e[0][1],g=e[1][1];g<0?(b.rotate=a.deg(w.acos(g)),f<0&&(b.rotate=360-b.rotate)):b.rotate=a.deg(w.asin(f)),b.isSimple=!+b.shear.toFixed(9)&&(b.scalex.toFixed(9)==b.scaley.toFixed(9)||!b.rotate),b.isSuperSimple=!+b.shear.toFixed(9)&&b.scalex.toFixed(9)==b.scaley.toFixed(9)&&!b.rotate,b.noRotation=!+b.shear.toFixed(9)&&!b.rotate;return b},b.toTransformString=function(a){var b=a||this[s]();if(b.isSimple){b.scalex=+b.scalex.toFixed(4),b.scaley=+b.scaley.toFixed(4),b.rotate=+b.rotate.toFixed(4);return(b.dx||b.dy?"t"+[b.dx,b.dy]:p)+(b.scalex!=1||b.scaley!=1?"s"+[b.scalex,b.scaley,0,0]:p)+(b.rotate?"r"+[b.rotate,0,0]:p)}return"m"+[this.get(0),this.get(1),this.get(2),this.get(3),this.get(4),this.get(5)]}}(cb.prototype);var cc=navigator.userAgent.match(/Version\/(.*?)\s/)||navigator.userAgent.match(/Chrome\/(\d+)/);navigator.vendor=="Apple Computer, Inc."&&(cc&&cc[1]<4||navigator.platform.slice(0,2)=="iP")||navigator.vendor=="Google Inc."&&cc&&cc[1]<8?k.safari=function(){var a=this.rect(-99,-99,this.width+99,this.height+99).attr({stroke:"none"});setTimeout(function(){a.remove()})}:k.safari=be;var cd=function(){this.returnValue=!1},ce=function(){return this.originalEvent.preventDefault()},cf=function(){this.cancelBubble=!0},cg=function(){return this.originalEvent.stopPropagation()},ch=function(){if(h.doc.addEventListener)return function(a,b,c,d){var e=o&&u[b]?u[b]:b,f=function(e){var f=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,i=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft,j=e.clientX+i,k=e.clientY+f;if(o&&u[g](b))for(var l=0,m=e.targetTouches&&e.targetTouches.length;l<m;l++)if(e.targetTouches[l].target==a){var n=e;e=e.targetTouches[l],e.originalEvent=n,e.preventDefault=ce,e.stopPropagation=cg;break}return c.call(d,e,j,k)};a.addEventListener(e,f,!1);return function(){a.removeEventListener(e,f,!1);return!0}};if(h.doc.attachEvent)return function(a,b,c,d){var e=function(a){a=a||h.win.event;var b=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,e=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft,f=a.clientX+e,g=a.clientY+b;a.preventDefault=a.preventDefault||cd,a.stopPropagation=a.stopPropagation||cf;return c.call(d,a,f,g)};a.attachEvent("on"+b,e);var f=function(){a.detachEvent("on"+b,e);return!0};return f}}(),ci=[],cj=function(a){var b=a.clientX,c=a.clientY,d=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,e=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft,f,g=ci.length;while(g--){f=ci[g];if(o){var i=a.touches.length,j;while(i--){j=a.touches[i];if(j.identifier==f.el._drag.id){b=j.clientX,c=j.clientY,(a.originalEvent?a.originalEvent:a).preventDefault();break}}}else a.preventDefault();var k=f.el.node,l,m=k.nextSibling,n=k.parentNode,p=k.style.display;h.win.opera&&n.removeChild(k),k.style.display="none",l=f.el.paper.getElementByPoint(b,c),k.style.display=p,h.win.opera&&(m?n.insertBefore(k,m):n.appendChild(k)),l&&eve("raphael.drag.over."+f.el.id,f.el,l),b+=e,c+=d,eve("raphael.drag.move."+f.el.id,f.move_scope||f.el,b-f.el._drag.x,c-f.el._drag.y,b,c,a)}},ck=function(b){a.unmousemove(cj).unmouseup(ck);var c=ci.length,d;while(c--)d=ci[c],d.el._drag={},eve("raphael.drag.end."+d.el.id,d.end_scope||d.start_scope||d.move_scope||d.el,b);ci=[]},cl=a.el={};for(var cm=t.length;cm--;)(function(b){a[b]=cl[b]=function(c,d){a.is(c,"function")&&(this.events=this.events||[],this.events.push({name:b,f:c,unbind:ch(this.shape||this.node||h.doc,b,c,d||this)}));return this},a["un"+b]=cl["un"+b]=function(a){var c=this.events||[],d=c.length;while(d--)if(c[d].name==b&&c[d].f==a){c[d].unbind(),c.splice(d,1),!c.length&&delete this.events;return this}return this}})(t[cm]);cl.data=function(b,c){var d=bb[this.id]=bb[this.id]||{};if(arguments.length==1){if(a.is(b,"object")){for(var e in b)b[g](e)&&this.data(e,b[e]);return this}eve("raphael.data.get."+this.id,this,d[b],b);return d[b]}d[b]=c,eve("raphael.data.set."+this.id,this,c,b);return this},cl.removeData=function(a){a==null?bb[this.id]={}:bb[this.id]&&delete bb[this.id][a];return this},cl.hover=function(a,b,c,d){return this.mouseover(a,c).mouseout(b,d||c)},cl.unhover=function(a,b){return this.unmouseover(a).unmouseout(b)};var cn=[];cl.drag=function(b,c,d,e,f,g){function i(i){(i.originalEvent||i).preventDefault();var j=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,k=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft;this._drag.x=i.clientX+k,this._drag.y=i.clientY+j,this._drag.id=i.identifier,!ci.length&&a.mousemove(cj).mouseup(ck),ci.push({el:this,move_scope:e,start_scope:f,end_scope:g}),c&&eve.on("raphael.drag.start."+this.id,c),b&&eve.on("raphael.drag.move."+this.id,b),d&&eve.on("raphael.drag.end."+this.id,d),eve("raphael.drag.start."+this.id,f||e||this,i.clientX+k,i.clientY+j,i)}this._drag={},cn.push({el:this,start:i}),this.mousedown(i);return this},cl.onDragOver=function(a){a?eve.on("raphael.drag.over."+this.id,a):eve.unbind("raphael.drag.over."+this.id)},cl.undrag=function(){var b=cn.length;while(b--)cn[b].el==this&&(this.unmousedown(cn[b].start),cn.splice(b,1),eve.unbind("raphael.drag.*."+this.id));!cn.length&&a.unmousemove(cj).unmouseup(ck)},k.circle=function(b,c,d){var e=a._engine.circle(this,b||0,c||0,d||0);this.__set__&&this.__set__.push(e);return e},k.rect=function(b,c,d,e,f){var g=a._engine.rect(this,b||0,c||0,d||0,e||0,f||0);this.__set__&&this.__set__.push(g);return g},k.ellipse=function(b,c,d,e){var f=a._engine.ellipse(this,b||0,c||0,d||0,e||0);this.__set__&&this.__set__.push(f);return f},k.path=function(b){b&&!a.is(b,D)&&!a.is(b[0],E)&&(b+=p);var c=a._engine.path(a.format[m](a,arguments),this);this.__set__&&this.__set__.push(c);return c},k.image=function(b,c,d,e,f){var g=a._engine.image(this,b||"about:blank",c||0,d||0,e||0,f||0);this.__set__&&this.__set__.push(g);return g},k.text=function(b,c,d){var e=a._engine.text(this,b||0,c||0,r(d));this.__set__&&this.__set__.push(e);return e},k.set=function(b){!a.is(b,"array")&&(b=Array.prototype.splice.call(arguments,0,arguments.length));var c=new cG(b);this.__set__&&this.__set__.push(c);return c},k.setStart=function(a){this.__set__=a||this.set()},k.setFinish=function(a){var b=this.__set__;delete this.__set__;return b},k.setSize=function(b,c){return a._engine.setSize.call(this,b,c)},k.setViewBox=function(b,c,d,e,f){return a._engine.setViewBox.call(this,b,c,d,e,f)},k.top=k.bottom=null,k.raphael=a;var co=function(a){var b=a.getBoundingClientRect(),c=a.ownerDocument,d=c.body,e=c.documentElement,f=e.clientTop||d.clientTop||0,g=e.clientLeft||d.clientLeft||0,i=b.top+(h.win.pageYOffset||e.scrollTop||d.scrollTop)-f,j=b.left+(h.win.pageXOffset||e.scrollLeft||d.scrollLeft)-g;return{y:i,x:j}};k.getElementByPoint=function(a,b){var c=this,d=c.canvas,e=h.doc.elementFromPoint(a,b);if(h.win.opera&&e.tagName=="svg"){var f=co(d),g=d.createSVGRect();g.x=a-f.x,g.y=b-f.y,g.width=g.height=1;var i=d.getIntersectionList(g,null);i.length&&(e=i[i.length-1])}if(!e)return null;while(e.parentNode&&e!=d.parentNode&&!e.raphael)e=e.parentNode;e==c.canvas.parentNode&&(e=d),e=e&&e.raphael?c.getById(e.raphaelid):null;return e},k.getById=function(a){var b=this.bottom;while(b){if(b.id==a)return b;b=b.next}return null},k.forEach=function(a,b){var c=this.bottom;while(c){if(a.call(b,c)===!1)return this;c=c.next}return this},k.getElementsByPoint=function(a,b){var c=this.set();this.forEach(function(d){d.isPointInside(a,b)&&c.push(d)});return c},cl.isPointInside=function(b,c){var d=this.realPath=this.realPath||bi[this.type](this);return a.isPointInsidePath(d,b,c)},cl.getBBox=function(a){if(this.removed)return{};var b=this._;if(a){if(b.dirty||!b.bboxwt)this.realPath=bi[this.type](this),b.bboxwt=bI(this.realPath),b.bboxwt.toString=cq,b.dirty=0;return b.bboxwt}if(b.dirty||b.dirtyT||!b.bbox){if(b.dirty||!this.realPath)b.bboxwt=0,this.realPath=bi[this.type](this);b.bbox=bI(bj(this.realPath,this.matrix)),b.bbox.toString=cq,b.dirty=b.dirtyT=0}return b.bbox},cl.clone=function(){if(this.removed)return null;var a=this.paper[this.type]().attr(this.attr());this.__set__&&this.__set__.push(a);return a},cl.glow=function(a){if(this.type=="text")return null;a=a||{};var b={width:(a.width||10)+(+this.attr("stroke-width")||1),fill:a.fill||!1,opacity:a.opacity||.5,offsetx:a.offsetx||0,offsety:a.offsety||0,color:a.color||"#000"},c=b.width/2,d=this.paper,e=d.set(),f=this.realPath||bi[this.type](this);f=this.matrix?bj(f,this.matrix):f;for(var g=1;g<c+1;g++)e.push(d.path(f).attr({stroke:b.color,fill:b.fill?b.color:"none","stroke-linejoin":"round","stroke-linecap":"round","stroke-width":+(b.width/c*g).toFixed(3),opacity:+(b.opacity/c).toFixed(3)}));return e.insertBefore(this).translate(b.offsetx,b.offsety)};var cr={},cs=function(b,c,d,e,f,g,h,i,j){return j==null?bB(b,c,d,e,f,g,h,i):a.findDotsAtSegment(b,c,d,e,f,g,h,i,bC(b,c,d,e,f,g,h,i,j))},ct=function(b,c){return function(d,e,f){d=bR(d);var g,h,i,j,k="",l={},m,n=0;for(var o=0,p=d.length;o<p;o++){i=d[o];if(i[0]=="M")g=+i[1],h=+i[2];else{j=cs(g,h,i[1],i[2],i[3],i[4],i[5],i[6]);if(n+j>e){if(c&&!l.start){m=cs(g,h,i[1],i[2],i[3],i[4],i[5],i[6],e-n),k+=["C"+m.start.x,m.start.y,m.m.x,m.m.y,m.x,m.y];if(f)return k;l.start=k,k=["M"+m.x,m.y+"C"+m.n.x,m.n.y,m.end.x,m.end.y,i[5],i[6]].join(),n+=j,g=+i[5],h=+i[6];continue}if(!b&&!c){m=cs(g,h,i[1],i[2],i[3],i[4],i[5],i[6],e-n);return{x:m.x,y:m.y,alpha:m.alpha}}}n+=j,g=+i[5],h=+i[6]}k+=i.shift()+i}l.end=k,m=b?n:c?l:a.findDotsAtSegment(g,h,i[0],i[1],i[2],i[3],i[4],i[5],1),m.alpha&&(m={x:m.x,y:m.y,alpha:m.alpha});return m}},cu=ct(1),cv=ct(),cw=ct(0,1);a.getTotalLength=cu,a.getPointAtLength=cv,a.getSubpath=function(a,b,c){if(this.getTotalLength(a)-c<1e-6)return cw(a,b).end;var d=cw(a,c,1);return b?cw(d,b).end:d},cl.getTotalLength=function(){if(this.type=="path"){if(this.node.getTotalLength)return this.node.getTotalLength();return cu(this.attrs.path)}},cl.getPointAtLength=function(a){if(this.type=="path")return cv(this.attrs.path,a)},cl.getSubpath=function(b,c){if(this.type=="path")return a.getSubpath(this.attrs.path,b,c)};var cx=a.easing_formulas={linear:function(a){return a},"<":function(a){return A(a,1.7)},">":function(a){return A(a,.48)},"<>":function(a){var b=.48-a/1.04,c=w.sqrt(.1734+b*b),d=c-b,e=A(z(d),1/3)*(d<0?-1:1),f=-c-b,g=A(z(f),1/3)*(f<0?-1:1),h=e+g+.5;return(1-h)*3*h*h+h*h*h},backIn:function(a){var b=1.70158;return a*a*((b+1)*a-b)},backOut:function(a){a=a-1;var b=1.70158;return a*a*((b+1)*a+b)+1},elastic:function(a){if(a==!!a)return a;return A(2,-10*a)*w.sin((a-.075)*2*B/.3)+1},bounce:function(a){var b=7.5625,c=2.75,d;a<1/c?d=b*a*a:a<2/c?(a-=1.5/c,d=b*a*a+.75):a<2.5/c?(a-=2.25/c,d=b*a*a+.9375):(a-=2.625/c,d=b*a*a+.984375);return d}};cx.easeIn=cx["ease-in"]=cx["<"],cx.easeOut=cx["ease-out"]=cx[">"],cx.easeInOut=cx["ease-in-out"]=cx["<>"],cx["back-in"]=cx.backIn,cx["back-out"]=cx.backOut;var cy=[],cz=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(a){setTimeout(a,16)},cA=function(){var b=+(new Date),c=0;for(;c<cy.length;c++){var d=cy[c];if(d.el.removed||d.paused)continue;var e=b-d.start,f=d.ms,h=d.easing,i=d.from,j=d.diff,k=d.to,l=d.t,m=d.el,o={},p,r={},s;d.initstatus?(e=(d.initstatus*d.anim.top-d.prev)/(d.percent-d.prev)*f,d.status=d.initstatus,delete d.initstatus,d.stop&&cy.splice(c--,1)):d.status=(d.prev+(d.percent-d.prev)*(e/f))/d.anim.top;if(e<0)continue;if(e<f){var t=h(e/f);for(var u in i)if(i[g](u)){switch(U[u]){case C:p=+i[u]+t*f*j[u];break;case"colour":p="rgb("+[cB(O(i[u].r+t*f*j[u].r)),cB(O(i[u].g+t*f*j[u].g)),cB(O(i[u].b+t*f*j[u].b))].join(",")+")";break;case"path":p=[];for(var v=0,w=i[u].length;v<w;v++){p[v]=[i[u][v][0]];for(var x=1,y=i[u][v].length;x<y;x++)p[v][x]=+i[u][v][x]+t*f*j[u][v][x];p[v]=p[v].join(q)}p=p.join(q);break;case"transform":if(j[u].real){p=[];for(v=0,w=i[u].length;v<w;v++){p[v]=[i[u][v][0]];for(x=1,y=i[u][v].length;x<y;x++)p[v][x]=i[u][v][x]+t*f*j[u][v][x]}}else{var z=function(a){return+i[u][a]+t*f*j[u][a]};p=[["m",z(0),z(1),z(2),z(3),z(4),z(5)]]}break;case"csv":if(u=="clip-rect"){p=[],v=4;while(v--)p[v]=+i[u][v]+t*f*j[u][v]}break;default:var A=[][n](i[u]);p=[],v=m.paper.customAttributes[u].length;while(v--)p[v]=+A[v]+t*f*j[u][v]}o[u]=p}m.attr(o),function(a,b,c){setTimeout(function(){eve("raphael.anim.frame."+a,b,c)})}(m.id,m,d.anim)}else{(function(b,c,d){setTimeout(function(){eve("raphael.anim.frame."+c.id,c,d),eve("raphael.anim.finish."+c.id,c,d),a.is(b,"function")&&b.call(c)})})(d.callback,m,d.anim),m.attr(k),cy.splice(c--,1);if(d.repeat>1&&!d.next){for(s in k)k[g](s)&&(r[s]=d.totalOrigin[s]);d.el.attr(r),cE(d.anim,d.el,d.anim.percents[0],null,d.totalOrigin,d.repeat-1)}d.next&&!d.stop&&cE(d.anim,d.el,d.next,null,d.totalOrigin,d.repeat)}}a.svg&&m&&m.paper&&m.paper.safari(),cy.length&&cz(cA)},cB=function(a){return a>255?255:a<0?0:a};cl.animateWith=function(b,c,d,e,f,g){var h=this;if(h.removed){g&&g.call(h);return h}var i=d instanceof cD?d:a.animation(d,e,f,g),j,k;cE(i,h,i.percents[0],null,h.attr());for(var l=0,m=cy.length;l<m;l++)if(cy[l].anim==c&&cy[l].el==b){cy[m-1].start=cy[l].start;break}return h},cl.onAnimation=function(a){a?eve.on("raphael.anim.frame."+this.id,a):eve.unbind("raphael.anim.frame."+this.id);return this},cD.prototype.delay=function(a){var b=new cD(this.anim,this.ms);b.times=this.times,b.del=+a||0;return b},cD.prototype.repeat=function(a){var b=new cD(this.anim,this.ms);b.del=this.del,b.times=w.floor(x(a,0))||1;return b},a.animation=function(b,c,d,e){if(b instanceof cD)return b;if(a.is(d,"function")||!d)e=e||d||null,d=null;b=Object(b),c=+c||0;var f={},h,i;for(i in b)b[g](i)&&Q(i)!=i&&Q(i)+"%"!=i&&(h=!0,f[i]=b[i]);if(!h)return new cD(b,c);d&&(f.easing=d),e&&(f.callback=e);return new cD({100:f},c)},cl.animate=function(b,c,d,e){var f=this;if(f.removed){e&&e.call(f);return f}var g=b instanceof cD?b:a.animation(b,c,d,e);cE(g,f,g.percents[0],null,f.attr());return f},cl.setTime=function(a,b){a&&b!=null&&this.status(a,y(b,a.ms)/a.ms);return this},cl.status=function(a,b){var c=[],d=0,e,f;if(b!=null){cE(a,this,-1,y(b,1));return this}e=cy.length;for(;d<e;d++){f=cy[d];if(f.el.id==this.id&&(!a||f.anim==a)){if(a)return f.status;c.push({anim:f.anim,status:f.status})}}if(a)return 0;return c},cl.pause=function(a){for(var b=0;b<cy.length;b++)cy[b].el.id==this.id&&(!a||cy[b].anim==a)&&eve("raphael.anim.pause."+this.id,this,cy[b].anim)!==!1&&(cy[b].paused=!0);return this},cl.resume=function(a){for(var b=0;b<cy.length;b++)if(cy[b].el.id==this.id&&(!a||cy[b].anim==a)){var c=cy[b];eve("raphael.anim.resume."+this.id,this,c.anim)!==!1&&(delete c.paused,this.status(c.anim,c.status))}return this},cl.stop=function(a){for(var b=0;b<cy.length;b++)cy[b].el.id==this.id&&(!a||cy[b].anim==a)&&eve("raphael.anim.stop."+this.id,this,cy[b].anim)!==!1&&cy.splice(b--,1);return this},eve.on("raphael.remove",cF),eve.on("raphael.clear",cF),cl.toString=function(){return"Raphaël’s object"};var cG=function(a){this.items=[],this.length=0,this.type="set";if(a)for(var b=0,c=a.length;b<c;b++)a[b]&&(a[b].constructor==cl.constructor||a[b].constructor==cG)&&(this[this.items.length]=this.items[this.items.length]=a[b],this.length++)},cH=cG.prototype;cH.push=function(){var a,b;for(var c=0,d=arguments.length;c<d;c++)a=arguments[c],a&&(a.constructor==cl.constructor||a.constructor==cG)&&(b=this.items.length,this[b]=this.items[b]=a,this.length++);return this},cH.pop=function(){this.length&&delete this[this.length--];return this.items.pop()},cH.forEach=function(a,b){for(var c=0,d=this.items.length;c<d;c++)if(a.call(b,this.items[c],c)===!1)return this;return this};for(var cI in cl)cl[g](cI)&&(cH[cI]=function(a){return function(){var b=arguments;return this.forEach(function(c){c[a][m](c,b)})}}(cI));cH.attr=function(b,c){if(b&&a.is(b,E)&&a.is(b[0],"object"))for(var d=0,e=b.length;d<e;d++)this.items[d].attr(b[d]);else for(var f=0,g=this.items.length;f<g;f++)this.items[f].attr(b,c);return this},cH.clear=function(){while(this.length)this.pop()},cH.splice=function(a,b,c){a=a<0?x(this.length+a,0):a,b=x(0,y(this.length-a,b));var d=[],e=[],f=[],g;for(g=2;g<arguments.length;g++)f.push(arguments[g]);for(g=0;g<b;g++)e.push(this[a+g]);for(;g<this.length-a;g++)d.push(this[a+g]);var h=f.length;for(g=0;g<h+d.length;g++)this.items[a+g]=this[a+g]=g<h?f[g]:d[g-h];g=this.items.length=this.length-=b-h;while(this[g])delete this[g++];return new cG(e)},cH.exclude=function(a){for(var b=0,c=this.length;b<c;b++)if(this[b]==a){this.splice(b,1);return!0}},cH.animate=function(b,c,d,e){(a.is(d,"function")||!d)&&(e=d||null);var f=this.items.length,g=f,h,i=this,j;if(!f)return this;e&&(j=function(){!--f&&e.call(i)}),d=a.is(d,D)?d:j;var k=a.animation(b,c,d,j);h=this.items[--g].animate(k);while(g--)this.items[g]&&!this.items[g].removed&&this.items[g].animateWith(h,k,k);return this},cH.insertAfter=function(a){var b=this.items.length;while(b--)this.items[b].insertAfter(a);return this},cH.getBBox=function(){var a=[],b=[],c=[],d=[];for(var e=this.items.length;e--;)if(!this.items[e].removed){var f=this.items[e].getBBox();a.push(f.x),b.push(f.y),c.push(f.x+f.width),d.push(f.y+f.height)}a=y[m](0,a),b=y[m](0,b),c=x[m](0,c),d=x[m](0,d);return{x:a,y:b,x2:c,y2:d,width:c-a,height:d-b}},cH.clone=function(a){a=new cG;for(var b=0,c=this.items.length;b<c;b++)a.push(this.items[b].clone());return a},cH.toString=function(){return"Raphaël‘s set"},a.registerFont=function(a){if(!a.face)return a;this.fonts=this.fonts||{};var b={w:a.w,face:{},glyphs:{}},c=a.face["font-family"];for(var d in a.face)a.face[g](d)&&(b.face[d]=a.face[d]);this.fonts[c]?this.fonts[c].push(b):this.fonts[c]=[b];if(!a.svg){b.face["units-per-em"]=R(a.face["units-per-em"],10);for(var e in a.glyphs)if(a.glyphs[g](e)){var f=a.glyphs[e];b.glyphs[e]={w:f.w,k:{},d:f.d&&"M"+f.d.replace(/[mlcxtrv]/g,function(a){return{l:"L",c:"C",x:"z",t:"m",r:"l",v:"c"}[a]||"M"})+"z"};if(f.k)for(var h in f.k)f[g](h)&&(b.glyphs[e].k[h]=f.k[h])}}return a},k.getFont=function(b,c,d,e){e=e||"normal",d=d||"normal",c=+c||{normal:400,bold:700,lighter:300,bolder:800}[c]||400;if(!!a.fonts){var f=a.fonts[b];if(!f){var h=new RegExp("(^|\\s)"+b.replace(/[^\w\d\s+!~.:_-]/g,p)+"(\\s|$)","i");for(var i in a.fonts)if(a.fonts[g](i)&&h.test(i)){f=a.fonts[i];break}}var j;if(f)for(var k=0,l=f.length;k<l;k++){j=f[k];if(j.face["font-weight"]==c&&(j.face["font-style"]==d||!j.face["font-style"])&&j.face["font-stretch"]==e)break}return j}},k.print=function(b,d,e,f,g,h,i){h=h||"middle",i=x(y(i||0,1),-1);var j=r(e)[s](p),k=0,l=0,m=p,n;a.is(f,e)&&(f=this.getFont(f));if(f){n=(g||16)/f.face["units-per-em"];var o=f.face.bbox[s](c),q=+o[0],t=o[3]-o[1],u=0,v=+o[1]+(h=="baseline"?t+ +f.face.descent:t/2);for(var w=0,z=j.length;w<z;w++){if(j[w]=="\n")k=0,B=0,l=0,u+=t;else{var A=l&&f.glyphs[j[w-1]]||{},B=f.glyphs[j[w]];k+=l?(A.w||f.w)+(A.k&&A.k[j[w]]||0)+f.w*i:0,l=1}B&&B.d&&(m+=a.transformPath(B.d,["t",k*n,u*n,"s",n,n,q,v,"t",(b-q)/n,(d-v)/n]))}}return this.path(m).attr({fill:"#000",stroke:"none"})},k.add=function(b){if(a.is(b,"array")){var c=this.set(),e=0,f=b.length,h;for(;e<f;e++)h=b[e]||{},d[g](h.type)&&c.push(this[h.type]().attr(h))}return c},a.format=function(b,c){var d=a.is(c,E)?[0][n](c):arguments;b&&a.is(b,D)&&d.length-1&&(b=b.replace(e,function(a,b){return d[++b]==null?p:d[b]}));return b||p},a.fullfill=function(){var a=/\{([^\}]+)\}/g,b=/(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g,c=function(a,c,d){var e=d;c.replace(b,function(a,b,c,d,f){b=b||d,e&&(b in e&&(e=e[b]),typeof e=="function"&&f&&(e=e()))}),e=(e==null||e==d?a:e)+"";return e};return function(b,d){return String(b).replace(a,function(a,b){return c(a,b,d)})}}(),a.ninja=function(){i.was?h.win.Raphael=i.is:delete Raphael;return a},a.st=cH,function(b,c,d){function e(){/in/.test(b.readyState)?setTimeout(e,9):a.eve("raphael.DOMload")}b.readyState==null&&b.addEventListener&&(b.addEventListener(c,d=function(){b.removeEventListener(c,d,!1),b.readyState="complete"},!1),b.readyState="loading"),e()}(document,"DOMContentLoaded"),i.was?h.win.Raphael=a:Raphael=a,eve.on("raphael.DOMload",function(){b=!0})}(),window.Raphael.svg&&function(a){var b="hasOwnProperty",c=String,d=parseFloat,e=parseInt,f=Math,g=f.max,h=f.abs,i=f.pow,j=/[, ]+/,k=a.eve,l="",m=" ",n="http://www.w3.org/1999/xlink",o={block:"M5,0 0,2.5 5,5z",classic:"M5,0 0,2.5 5,5 3.5,3 3.5,2z",diamond:"M2.5,0 5,2.5 2.5,5 0,2.5z",open:"M6,1 1,3.5 6,6",oval:"M2.5,0A2.5,2.5,0,0,1,2.5,5 2.5,2.5,0,0,1,2.5,0z"},p={};a.toString=function(){return"Your browser supports SVG.\nYou are running Raphaël "+this.version};var q=function(d,e){if(e){typeof d=="string"&&(d=q(d));for(var f in e)e[b](f)&&(f.substring(0,6)=="xlink:"?d.setAttributeNS(n,f.substring(6),c(e[f])):d.setAttribute(f,c(e[f])))}else d=a._g.doc.createElementNS("http://www.w3.org/2000/svg",d),d.style&&(d.style.webkitTapHighlightColor="rgba(0,0,0,0)");return d},r=function(b,e){var j="linear",k=b.id+e,m=.5,n=.5,o=b.node,p=b.paper,r=o.style,s=a._g.doc.getElementById(k);if(!s){e=c(e).replace(a._radial_gradient,function(a,b,c){j="radial";if(b&&c){m=d(b),n=d(c);var e=(n>.5)*2-1;i(m-.5,2)+i(n-.5,2)>.25&&(n=f.sqrt(.25-i(m-.5,2))*e+.5)&&n!=.5&&(n=n.toFixed(5)-1e-5*e)}return l}),e=e.split(/\s*\-\s*/);if(j=="linear"){var t=e.shift();t=-d(t);if(isNaN(t))return null;var u=[0,0,f.cos(a.rad(t)),f.sin(a.rad(t))],v=1/(g(h(u[2]),h(u[3]))||1);u[2]*=v,u[3]*=v,u[2]<0&&(u[0]=-u[2],u[2]=0),u[3]<0&&(u[1]=-u[3],u[3]=0)}var w=a._parseDots(e);if(!w)return null;k=k.replace(/[\(\)\s,\xb0#]/g,"_"),b.gradient&&k!=b.gradient.id&&(p.defs.removeChild(b.gradient),delete b.gradient);if(!b.gradient){s=q(j+"Gradient",{id:k}),b.gradient=s,q(s,j=="radial"?{fx:m,fy:n}:{x1:u[0],y1:u[1],x2:u[2],y2:u[3],gradientTransform:b.matrix.invert()}),p.defs.appendChild(s);for(var x=0,y=w.length;x<y;x++)s.appendChild(q("stop",{offset:w[x].offset?w[x].offset:x?"100%":"0%","stop-color":w[x].color||"#fff"}))}}q(o,{fill:"url(#"+k+")",opacity:1,"fill-opacity":1}),r.fill=l,r.opacity=1,r.fillOpacity=1;return 1},s=function(a){var b=a.getBBox(1);q(a.pattern,{patternTransform:a.matrix.invert()+" translate("+b.x+","+b.y+")"})},t=function(d,e,f){if(d.type=="path"){var g=c(e).toLowerCase().split("-"),h=d.paper,i=f?"end":"start",j=d.node,k=d.attrs,m=k["stroke-width"],n=g.length,r="classic",s,t,u,v,w,x=3,y=3,z=5;while(n--)switch(g[n]){case"block":case"classic":case"oval":case"diamond":case"open":case"none":r=g[n];break;case"wide":y=5;break;case"narrow":y=2;break;case"long":x=5;break;case"short":x=2}r=="open"?(x+=2,y+=2,z+=2,u=1,v=f?4:1,w={fill:"none",stroke:k.stroke}):(v=u=x/2,w={fill:k.stroke,stroke:"none"}),d._.arrows?f?(d._.arrows.endPath&&p[d._.arrows.endPath]--,d._.arrows.endMarker&&p[d._.arrows.endMarker]--):(d._.arrows.startPath&&p[d._.arrows.startPath]--,d._.arrows.startMarker&&p[d._.arrows.startMarker]--):d._.arrows={};if(r!="none"){var A="raphael-marker-"+r,B="raphael-marker-"+i+r+x+y;a._g.doc.getElementById(A)?p[A]++:(h.defs.appendChild(q(q("path"),{"stroke-linecap":"round",d:o[r],id:A})),p[A]=1);var C=a._g.doc.getElementById(B),D;C?(p[B]++,D=C.getElementsByTagName("use")[0]):(C=q(q("marker"),{id:B,markerHeight:y,markerWidth:x,orient:"auto",refX:v,refY:y/2}),D=q(q("use"),{"xlink:href":"#"+A,transform:(f?"rotate(180 "+x/2+" "+y/2+") ":l)+"scale("+x/z+","+y/z+")","stroke-width":(1/((x/z+y/z)/2)).toFixed(4)}),C.appendChild(D),h.defs.appendChild(C),p[B]=1),q(D,w);var F=u*(r!="diamond"&&r!="oval");f?(s=d._.arrows.startdx*m||0,t=a.getTotalLength(k.path)-F*m):(s=F*m,t=a.getTotalLength(k.path)-(d._.arrows.enddx*m||0)),w={},w["marker-"+i]="url(#"+B+")";if(t||s)w.d=Raphael.getSubpath(k.path,s,t);q(j,w),d._.arrows[i+"Path"]=A,d._.arrows[i+"Marker"]=B,d._.arrows[i+"dx"]=F,d._.arrows[i+"Type"]=r,d._.arrows[i+"String"]=e}else f?(s=d._.arrows.startdx*m||0,t=a.getTotalLength(k.path)-s):(s=0,t=a.getTotalLength(k.path)-(d._.arrows.enddx*m||0)),d._.arrows[i+"Path"]&&q(j,{d:Raphael.getSubpath(k.path,s,t)}),delete d._.arrows[i+"Path"],delete d._.arrows[i+"Marker"],delete d._.arrows[i+"dx"],delete d._.arrows[i+"Type"],delete d._.arrows[i+"String"];for(w in p)if(p[b](w)&&!p[w]){var G=a._g.doc.getElementById(w);G&&G.parentNode.removeChild(G)}}},u={"":[0],none:[0],"-":[3,1],".":[1,1],"-.":[3,1,1,1],"-..":[3,1,1,1,1,1],". ":[1,3],"- ":[4,3],"--":[8,3],"- .":[4,3,1,3],"--.":[8,3,1,3],"--..":[8,3,1,3,1,3]},v=function(a,b,d){b=u[c(b).toLowerCase()];if(b){var e=a.attrs["stroke-width"]||"1",f={round:e,square:e,butt:0}[a.attrs["stroke-linecap"]||d["stroke-linecap"]]||0,g=[],h=b.length;while(h--)g[h]=b[h]*e+(h%2?1:-1)*f;q(a.node,{"stroke-dasharray":g.join(",")})}},w=function(d,f){var i=d.node,k=d.attrs,m=i.style.visibility;i.style.visibility="hidden";for(var o in f)if(f[b](o)){if(!a._availableAttrs[b](o))continue;var p=f[o];k[o]=p;switch(o){case"blur":d.blur(p);break;case"href":case"title":case"target":var u=i.parentNode;if(u.tagName.toLowerCase()!="a"){var w=q("a");u.insertBefore(w,i),w.appendChild(i),u=w}o=="target"?u.setAttributeNS(n,"show",p=="blank"?"new":p):u.setAttributeNS(n,o,p);break;case"cursor":i.style.cursor=p;break;case"transform":d.transform(p);break;case"arrow-start":t(d,p);break;case"arrow-end":t(d,p,1);break;case"clip-rect":var x=c(p).split(j);if(x.length==4){d.clip&&d.clip.parentNode.parentNode.removeChild(d.clip.parentNode);var z=q("clipPath"),A=q("rect");z.id=a.createUUID(),q(A,{x:x[0],y:x[1],width:x[2],height:x[3]}),z.appendChild(A),d.paper.defs.appendChild(z),q(i,{"clip-path":"url(#"+z.id+")"}),d.clip=A}if(!p){var B=i.getAttribute("clip-path");if(B){var C=a._g.doc.getElementById(B.replace(/(^url\(#|\)$)/g,l));C&&C.parentNode.removeChild(C),q(i,{"clip-path":l}),delete d.clip}}break;case"path":d.type=="path"&&(q(i,{d:p?k.path=a._pathToAbsolute(p):"M0,0"}),d._.dirty=1,d._.arrows&&("startString"in d._.arrows&&t(d,d._.arrows.startString),"endString"in d._.arrows&&t(d,d._.arrows.endString,1)));break;case"width":i.setAttribute(o,p),d._.dirty=1;if(k.fx)o="x",p=k.x;else break;case"x":k.fx&&(p=-k.x-(k.width||0));case"rx":if(o=="rx"&&d.type=="rect")break;case"cx":i.setAttribute(o,p),d.pattern&&s(d),d._.dirty=1;break;case"height":i.setAttribute(o,p),d._.dirty=1;if(k.fy)o="y",p=k.y;else break;case"y":k.fy&&(p=-k.y-(k.height||0));case"ry":if(o=="ry"&&d.type=="rect")break;case"cy":i.setAttribute(o,p),d.pattern&&s(d),d._.dirty=1;break;case"r":d.type=="rect"?q(i,{rx:p,ry:p}):i.setAttribute(o,p),d._.dirty=1;break;case"src":d.type=="image"&&i.setAttributeNS(n,"href",p);break;case"stroke-width":if(d._.sx!=1||d._.sy!=1)p/=g(h(d._.sx),h(d._.sy))||1;d.paper._vbSize&&(p*=d.paper._vbSize),i.setAttribute(o,p),k["stroke-dasharray"]&&v(d,k["stroke-dasharray"],f),d._.arrows&&("startString"in d._.arrows&&t(d,d._.arrows.startString),"endString"in d._.arrows&&t(d,d._.arrows.endString,1));break;case"stroke-dasharray":v(d,p,f);break;case"fill":var D=c(p).match(a._ISURL);if(D){z=q("pattern");var F=q("image");z.id=a.createUUID(),q(z,{x:0,y:0,patternUnits:"userSpaceOnUse",height:1,width:1}),q(F,{x:0,y:0,"xlink:href":D[1]}),z.appendChild(F),function(b){a._preload(D[1],function(){var a=this.offsetWidth,c=this.offsetHeight;q(b,{width:a,height:c}),q(F,{width:a,height:c}),d.paper.safari()})}(z),d.paper.defs.appendChild(z),q(i,{fill:"url(#"+z.id+")"}),d.pattern=z,d.pattern&&s(d);break}var G=a.getRGB(p);if(!G.error)delete f.gradient,delete k.gradient,!a.is(k.opacity,"undefined")&&a.is(f.opacity,"undefined")&&q(i,{opacity:k.opacity}),!a.is(k["fill-opacity"],"undefined")&&a.is(f["fill-opacity"],"undefined")&&q(i,{"fill-opacity":k["fill-opacity"]});else if((d.type=="circle"||d.type=="ellipse"||c(p).charAt()!="r")&&r(d,p)){if("opacity"in k||"fill-opacity"in k){var H=a._g.doc.getElementById(i.getAttribute("fill").replace(/^url\(#|\)$/g,l));if(H){var I=H.getElementsByTagName("stop");q(I[I.length-1],{"stop-opacity":("opacity"in k?k.opacity:1)*("fill-opacity"in k?k["fill-opacity"]:1)})}}k.gradient=p,k.fill="none";break}G[b]("opacity")&&q(i,{"fill-opacity":G.opacity>1?G.opacity/100:G.opacity});case"stroke":G=a.getRGB(p),i.setAttribute(o,G.hex),o=="stroke"&&G[b]("opacity")&&q(i,{"stroke-opacity":G.opacity>1?G.opacity/100:G.opacity}),o=="stroke"&&d._.arrows&&("startString"in d._.arrows&&t(d,d._.arrows.startString),"endString"in d._.arrows&&t(d,d._.arrows.endString,1));break;case"gradient":(d.type=="circle"||d.type=="ellipse"||c(p).charAt()!="r")&&r(d,p);break;case"opacity":k.gradient&&!k[b]("stroke-opacity")&&q(i,{"stroke-opacity":p>1?p/100:p});case"fill-opacity":if(k.gradient){H=a._g.doc.getElementById(i.getAttribute("fill").replace(/^url\(#|\)$/g,l)),H&&(I=H.getElementsByTagName("stop"),q(I[I.length-1],{"stop-opacity":p}));break};default:o=="font-size"&&(p=e(p,10)+"px");var J=o.replace(/(\-.)/g,function(a){return a.substring(1).toUpperCase()});i.style[J]=p,d._.dirty=1,i.setAttribute(o,p)}}y(d,f),i.style.visibility=m},x=1.2,y=function(d,f){if(d.type=="text"&&!!(f[b]("text")||f[b]("font")||f[b]("font-size")||f[b]("x")||f[b]("y"))){var g=d.attrs,h=d.node,i=h.firstChild?e(a._g.doc.defaultView.getComputedStyle(h.firstChild,l).getPropertyValue("font-size"),10):10;if(f[b]("text")){g.text=f.text;while(h.firstChild)h.removeChild(h.firstChild);var j=c(f.text).split("\n"),k=[],m;for(var n=0,o=j.length;n<o;n++)m=q("tspan"),n&&q(m,{dy:i*x,x:g.x}),m.appendChild(a._g.doc.createTextNode(j[n])),h.appendChild(m),k[n]=m}else{k=h.getElementsByTagName("tspan");for(n=0,o=k.length;n<o;n++)n?q(k[n],{dy:i*x,x:g.x}):q(k[0],{dy:0})}q(h,{x:g.x,y:g.y}),d._.dirty=1;var p=d._getBBox(),r=g.y-(p.y+p.height/2);r&&a.is(r,"finite")&&q(k[0],{dy:r})}},z=function(b,c){var d=0,e=0;this[0]=this.node=b,b.raphael=!0,this.id=a._oid++,b.raphaelid=this.id,this.matrix=a.matrix(),this.realPath=null,this.paper=c,this.attrs=this.attrs||{},this._={transform:[],sx:1,sy:1,deg:0,dx:0,dy:0,dirty:1},!c.bottom&&(c.bottom=this),this.prev=c.top,c.top&&(c.top.next=this),c.top=this,this.next=null},A=a.el;z.prototype=A,A.constructor=z,a._engine.path=function(a,b){var c=q("path");b.canvas&&b.canvas.appendChild(c);var d=new z(c,b);d.type="path",w(d,{fill:"none",stroke:"#000",path:a});return d},A.rotate=function(a,b,e){if(this.removed)return this;a=c(a).split(j),a.length-1&&(b=d(a[1]),e=d(a[2])),a=d(a[0]),e==null&&(b=e);if(b==null||e==null){var f=this.getBBox(1);b=f.x+f.width/2,e=f.y+f.height/2}this.transform(this._.transform.concat([["r",a,b,e]]));return this},A.scale=function(a,b,e,f){if(this.removed)return this;a=c(a).split(j),a.length-1&&(b=d(a[1]),e=d(a[2]),f=d(a[3])),a=d(a[0]),b==null&&(b=a),f==null&&(e=f);if(e==null||f==null)var g=this.getBBox(1);e=e==null?g.x+g.width/2:e,f=f==null?g.y+g.height/2:f,this.transform(this._.transform.concat([["s",a,b,e,f]]));return this},A.translate=function(a,b){if(this.removed)return this;a=c(a).split(j),a.length-1&&(b=d(a[1])),a=d(a[0])||0,b=+b||0,this.transform(this._.transform.concat([["t",a,b]]));return this},A.transform=function(c){var d=this._;if(c==null)return d.transform;a._extractTransform(this,c),this.clip&&q(this.clip,{transform:this.matrix.invert()}),this.pattern&&s(this),this.node&&q(this.node,{transform:this.matrix});if(d.sx!=1||d.sy!=1){var e=this.attrs[b]("stroke-width")?this.attrs["stroke-width"]:1;this.attr({"stroke-width":e})}return this},A.hide=function(){!this.removed&&this.paper.safari(this.node.style.display="none");return this},A.show=function(){!
+this.removed&&this.paper.safari(this.node.style.display="");return this},A.remove=function(){if(!this.removed&&!!this.node.parentNode){var b=this.paper;b.__set__&&b.__set__.exclude(this),k.unbind("raphael.*.*."+this.id),this.gradient&&b.defs.removeChild(this.gradient),a._tear(this,b),this.node.parentNode.tagName.toLowerCase()=="a"?this.node.parentNode.parentNode.removeChild(this.node.parentNode):this.node.parentNode.removeChild(this.node);for(var c in this)this[c]=typeof this[c]=="function"?a._removedFactory(c):null;this.removed=!0}},A._getBBox=function(){if(this.node.style.display=="none"){this.show();var a=!0}var b={};try{b=this.node.getBBox()}catch(c){}finally{b=b||{}}a&&this.hide();return b},A.attr=function(c,d){if(this.removed)return this;if(c==null){var e={};for(var f in this.attrs)this.attrs[b](f)&&(e[f]=this.attrs[f]);e.gradient&&e.fill=="none"&&(e.fill=e.gradient)&&delete e.gradient,e.transform=this._.transform;return e}if(d==null&&a.is(c,"string")){if(c=="fill"&&this.attrs.fill=="none"&&this.attrs.gradient)return this.attrs.gradient;if(c=="transform")return this._.transform;var g=c.split(j),h={};for(var i=0,l=g.length;i<l;i++)c=g[i],c in this.attrs?h[c]=this.attrs[c]:a.is(this.paper.customAttributes[c],"function")?h[c]=this.paper.customAttributes[c].def:h[c]=a._availableAttrs[c];return l-1?h:h[g[0]]}if(d==null&&a.is(c,"array")){h={};for(i=0,l=c.length;i<l;i++)h[c[i]]=this.attr(c[i]);return h}if(d!=null){var m={};m[c]=d}else c!=null&&a.is(c,"object")&&(m=c);for(var n in m)k("raphael.attr."+n+"."+this.id,this,m[n]);for(n in this.paper.customAttributes)if(this.paper.customAttributes[b](n)&&m[b](n)&&a.is(this.paper.customAttributes[n],"function")){var o=this.paper.customAttributes[n].apply(this,[].concat(m[n]));this.attrs[n]=m[n];for(var p in o)o[b](p)&&(m[p]=o[p])}w(this,m);return this},A.toFront=function(){if(this.removed)return this;this.node.parentNode.tagName.toLowerCase()=="a"?this.node.parentNode.parentNode.appendChild(this.node.parentNode):this.node.parentNode.appendChild(this.node);var b=this.paper;b.top!=this&&a._tofront(this,b);return this},A.toBack=function(){if(this.removed)return this;var b=this.node.parentNode;b.tagName.toLowerCase()=="a"?b.parentNode.insertBefore(this.node.parentNode,this.node.parentNode.parentNode.firstChild):b.firstChild!=this.node&&b.insertBefore(this.node,this.node.parentNode.firstChild),a._toback(this,this.paper);var c=this.paper;return this},A.insertAfter=function(b){if(this.removed)return this;var c=b.node||b[b.length-1].node;c.nextSibling?c.parentNode.insertBefore(this.node,c.nextSibling):c.parentNode.appendChild(this.node),a._insertafter(this,b,this.paper);return this},A.insertBefore=function(b){if(this.removed)return this;var c=b.node||b[0].node;c.parentNode.insertBefore(this.node,c),a._insertbefore(this,b,this.paper);return this},A.blur=function(b){var c=this;if(+b!==0){var d=q("filter"),e=q("feGaussianBlur");c.attrs.blur=b,d.id=a.createUUID(),q(e,{stdDeviation:+b||1.5}),d.appendChild(e),c.paper.defs.appendChild(d),c._blur=d,q(c.node,{filter:"url(#"+d.id+")"})}else c._blur&&(c._blur.parentNode.removeChild(c._blur),delete c._blur,delete c.attrs.blur),c.node.removeAttribute("filter")},a._engine.circle=function(a,b,c,d){var e=q("circle");a.canvas&&a.canvas.appendChild(e);var f=new z(e,a);f.attrs={cx:b,cy:c,r:d,fill:"none",stroke:"#000"},f.type="circle",q(e,f.attrs);return f},a._engine.rect=function(a,b,c,d,e,f){var g=q("rect");a.canvas&&a.canvas.appendChild(g);var h=new z(g,a);h.attrs={x:b,y:c,width:d,height:e,r:f||0,rx:f||0,ry:f||0,fill:"none",stroke:"#000"},h.type="rect",q(g,h.attrs);return h},a._engine.ellipse=function(a,b,c,d,e){var f=q("ellipse");a.canvas&&a.canvas.appendChild(f);var g=new z(f,a);g.attrs={cx:b,cy:c,rx:d,ry:e,fill:"none",stroke:"#000"},g.type="ellipse",q(f,g.attrs);return g},a._engine.image=function(a,b,c,d,e,f){var g=q("image");q(g,{x:c,y:d,width:e,height:f,preserveAspectRatio:"none"}),g.setAttributeNS(n,"href",b),a.canvas&&a.canvas.appendChild(g);var h=new z(g,a);h.attrs={x:c,y:d,width:e,height:f,src:b},h.type="image";return h},a._engine.text=function(b,c,d,e){var f=q("text");b.canvas&&b.canvas.appendChild(f);var g=new z(f,b);g.attrs={x:c,y:d,"text-anchor":"middle",text:e,font:a._availableAttrs.font,stroke:"none",fill:"#000"},g.type="text",w(g,g.attrs);return g},a._engine.setSize=function(a,b){this.width=a||this.width,this.height=b||this.height,this.canvas.setAttribute("width",this.width),this.canvas.setAttribute("height",this.height),this._viewBox&&this.setViewBox.apply(this,this._viewBox);return this},a._engine.create=function(){var b=a._getContainer.apply(0,arguments),c=b&&b.container,d=b.x,e=b.y,f=b.width,g=b.height;if(!c)throw new Error("SVG container not found.");var h=q("svg"),i="overflow:hidden;",j;d=d||0,e=e||0,f=f||512,g=g||342,q(h,{height:g,version:1.1,width:f,xmlns:"http://www.w3.org/2000/svg"}),c==1?(h.style.cssText=i+"position:absolute;left:"+d+"px;top:"+e+"px",a._g.doc.body.appendChild(h),j=1):(h.style.cssText=i+"position:relative",c.firstChild?c.insertBefore(h,c.firstChild):c.appendChild(h)),c=new a._Paper,c.width=f,c.height=g,c.canvas=h,c.clear(),c._left=c._top=0,j&&(c.renderfix=function(){}),c.renderfix();return c},a._engine.setViewBox=function(a,b,c,d,e){k("raphael.setViewBox",this,this._viewBox,[a,b,c,d,e]);var f=g(c/this.width,d/this.height),h=this.top,i=e?"meet":"xMinYMin",j,l;a==null?(this._vbSize&&(f=1),delete this._vbSize,j="0 0 "+this.width+m+this.height):(this._vbSize=f,j=a+m+b+m+c+m+d),q(this.canvas,{viewBox:j,preserveAspectRatio:i});while(f&&h)l="stroke-width"in h.attrs?h.attrs["stroke-width"]:1,h.attr({"stroke-width":l}),h._.dirty=1,h._.dirtyT=1,h=h.prev;this._viewBox=[a,b,c,d,!!e];return this},a.prototype.renderfix=function(){var a=this.canvas,b=a.style,c;try{c=a.getScreenCTM()||a.createSVGMatrix()}catch(d){c=a.createSVGMatrix()}var e=-c.e%1,f=-c.f%1;if(e||f)e&&(this._left=(this._left+e)%1,b.left=this._left+"px"),f&&(this._top=(this._top+f)%1,b.top=this._top+"px")},a.prototype.clear=function(){a.eve("raphael.clear",this);var b=this.canvas;while(b.firstChild)b.removeChild(b.firstChild);this.bottom=this.top=null,(this.desc=q("desc")).appendChild(a._g.doc.createTextNode("Created with Raphaël "+a.version)),b.appendChild(this.desc),b.appendChild(this.defs=q("defs"))},a.prototype.remove=function(){k("raphael.remove",this),this.canvas.parentNode&&this.canvas.parentNode.removeChild(this.canvas);for(var b in this)this[b]=typeof this[b]=="function"?a._removedFactory(b):null};var B=a.st;for(var C in A)A[b](C)&&!B[b](C)&&(B[C]=function(a){return function(){var b=arguments;return this.forEach(function(c){c[a].apply(c,b)})}}(C))}(window.Raphael),window.Raphael.vml&&function(a){var b="hasOwnProperty",c=String,d=parseFloat,e=Math,f=e.round,g=e.max,h=e.min,i=e.abs,j="fill",k=/[, ]+/,l=a.eve,m=" progid:DXImageTransform.Microsoft",n=" ",o="",p={M:"m",L:"l",C:"c",Z:"x",m:"t",l:"r",c:"v",z:"x"},q=/([clmz]),?([^clmz]*)/gi,r=/ progid:\S+Blur\([^\)]+\)/g,s=/-?[^,\s-]+/g,t="position:absolute;left:0;top:0;width:1px;height:1px",u=21600,v={path:1,rect:1,image:1},w={circle:1,ellipse:1},x=function(b){var d=/[ahqstv]/ig,e=a._pathToAbsolute;c(b).match(d)&&(e=a._path2curve),d=/[clmz]/g;if(e==a._pathToAbsolute&&!c(b).match(d)){var g=c(b).replace(q,function(a,b,c){var d=[],e=b.toLowerCase()=="m",g=p[b];c.replace(s,function(a){e&&d.length==2&&(g+=d+p[b=="m"?"l":"L"],d=[]),d.push(f(a*u))});return g+d});return g}var h=e(b),i,j;g=[];for(var k=0,l=h.length;k<l;k++){i=h[k],j=h[k][0].toLowerCase(),j=="z"&&(j="x");for(var m=1,r=i.length;m<r;m++)j+=f(i[m]*u)+(m!=r-1?",":o);g.push(j)}return g.join(n)},y=function(b,c,d){var e=a.matrix();e.rotate(-b,.5,.5);return{dx:e.x(c,d),dy:e.y(c,d)}},z=function(a,b,c,d,e,f){var g=a._,h=a.matrix,k=g.fillpos,l=a.node,m=l.style,o=1,p="",q,r=u/b,s=u/c;m.visibility="hidden";if(!!b&&!!c){l.coordsize=i(r)+n+i(s),m.rotation=f*(b*c<0?-1:1);if(f){var t=y(f,d,e);d=t.dx,e=t.dy}b<0&&(p+="x"),c<0&&(p+=" y")&&(o=-1),m.flip=p,l.coordorigin=d*-r+n+e*-s;if(k||g.fillsize){var v=l.getElementsByTagName(j);v=v&&v[0],l.removeChild(v),k&&(t=y(f,h.x(k[0],k[1]),h.y(k[0],k[1])),v.position=t.dx*o+n+t.dy*o),g.fillsize&&(v.size=g.fillsize[0]*i(b)+n+g.fillsize[1]*i(c)),l.appendChild(v)}m.visibility="visible"}};a.toString=function(){return"Your browser doesn’t support SVG. Falling down to VML.\nYou are running Raphaël "+this.version};var A=function(a,b,d){var e=c(b).toLowerCase().split("-"),f=d?"end":"start",g=e.length,h="classic",i="medium",j="medium";while(g--)switch(e[g]){case"block":case"classic":case"oval":case"diamond":case"open":case"none":h=e[g];break;case"wide":case"narrow":j=e[g];break;case"long":case"short":i=e[g]}var k=a.node.getElementsByTagName("stroke")[0];k[f+"arrow"]=h,k[f+"arrowlength"]=i,k[f+"arrowwidth"]=j},B=function(e,i){e.attrs=e.attrs||{};var l=e.node,m=e.attrs,p=l.style,q,r=v[e.type]&&(i.x!=m.x||i.y!=m.y||i.width!=m.width||i.height!=m.height||i.cx!=m.cx||i.cy!=m.cy||i.rx!=m.rx||i.ry!=m.ry||i.r!=m.r),s=w[e.type]&&(m.cx!=i.cx||m.cy!=i.cy||m.r!=i.r||m.rx!=i.rx||m.ry!=i.ry),t=e;for(var y in i)i[b](y)&&(m[y]=i[y]);r&&(m.path=a._getPath[e.type](e),e._.dirty=1),i.href&&(l.href=i.href),i.title&&(l.title=i.title),i.target&&(l.target=i.target),i.cursor&&(p.cursor=i.cursor),"blur"in i&&e.blur(i.blur);if(i.path&&e.type=="path"||r)l.path=x(~c(m.path).toLowerCase().indexOf("r")?a._pathToAbsolute(m.path):m.path),e.type=="image"&&(e._.fillpos=[m.x,m.y],e._.fillsize=[m.width,m.height],z(e,1,1,0,0,0));"transform"in i&&e.transform(i.transform);if(s){var B=+m.cx,D=+m.cy,E=+m.rx||+m.r||0,G=+m.ry||+m.r||0;l.path=a.format("ar{0},{1},{2},{3},{4},{1},{4},{1}x",f((B-E)*u),f((D-G)*u),f((B+E)*u),f((D+G)*u),f(B*u))}if("clip-rect"in i){var H=c(i["clip-rect"]).split(k);if(H.length==4){H[2]=+H[2]+ +H[0],H[3]=+H[3]+ +H[1];var I=l.clipRect||a._g.doc.createElement("div"),J=I.style;J.clip=a.format("rect({1}px {2}px {3}px {0}px)",H),l.clipRect||(J.position="absolute",J.top=0,J.left=0,J.width=e.paper.width+"px",J.height=e.paper.height+"px",l.parentNode.insertBefore(I,l),I.appendChild(l),l.clipRect=I)}i["clip-rect"]||l.clipRect&&(l.clipRect.style.clip="auto")}if(e.textpath){var K=e.textpath.style;i.font&&(K.font=i.font),i["font-family"]&&(K.fontFamily='"'+i["font-family"].split(",")[0].replace(/^['"]+|['"]+$/g,o)+'"'),i["font-size"]&&(K.fontSize=i["font-size"]),i["font-weight"]&&(K.fontWeight=i["font-weight"]),i["font-style"]&&(K.fontStyle=i["font-style"])}"arrow-start"in i&&A(t,i["arrow-start"]),"arrow-end"in i&&A(t,i["arrow-end"],1);if(i.opacity!=null||i["stroke-width"]!=null||i.fill!=null||i.src!=null||i.stroke!=null||i["stroke-width"]!=null||i["stroke-opacity"]!=null||i["fill-opacity"]!=null||i["stroke-dasharray"]!=null||i["stroke-miterlimit"]!=null||i["stroke-linejoin"]!=null||i["stroke-linecap"]!=null){var L=l.getElementsByTagName(j),M=!1;L=L&&L[0],!L&&(M=L=F(j)),e.type=="image"&&i.src&&(L.src=i.src),i.fill&&(L.on=!0);if(L.on==null||i.fill=="none"||i.fill===null)L.on=!1;if(L.on&&i.fill){var N=c(i.fill).match(a._ISURL);if(N){L.parentNode==l&&l.removeChild(L),L.rotate=!0,L.src=N[1],L.type="tile";var O=e.getBBox(1);L.position=O.x+n+O.y,e._.fillpos=[O.x,O.y],a._preload(N[1],function(){e._.fillsize=[this.offsetWidth,this.offsetHeight]})}else L.color=a.getRGB(i.fill).hex,L.src=o,L.type="solid",a.getRGB(i.fill).error&&(t.type in{circle:1,ellipse:1}||c(i.fill).charAt()!="r")&&C(t,i.fill,L)&&(m.fill="none",m.gradient=i.fill,L.rotate=!1)}if("fill-opacity"in i||"opacity"in i){var P=((+m["fill-opacity"]+1||2)-1)*((+m.opacity+1||2)-1)*((+a.getRGB(i.fill).o+1||2)-1);P=h(g(P,0),1),L.opacity=P,L.src&&(L.color="none")}l.appendChild(L);var Q=l.getElementsByTagName("stroke")&&l.getElementsByTagName("stroke")[0],T=!1;!Q&&(T=Q=F("stroke"));if(i.stroke&&i.stroke!="none"||i["stroke-width"]||i["stroke-opacity"]!=null||i["stroke-dasharray"]||i["stroke-miterlimit"]||i["stroke-linejoin"]||i["stroke-linecap"])Q.on=!0;(i.stroke=="none"||i.stroke===null||Q.on==null||i.stroke==0||i["stroke-width"]==0)&&(Q.on=!1);var U=a.getRGB(i.stroke);Q.on&&i.stroke&&(Q.color=U.hex),P=((+m["stroke-opacity"]+1||2)-1)*((+m.opacity+1||2)-1)*((+U.o+1||2)-1);var V=(d(i["stroke-width"])||1)*.75;P=h(g(P,0),1),i["stroke-width"]==null&&(V=m["stroke-width"]),i["stroke-width"]&&(Q.weight=V),V&&V<1&&(P*=V)&&(Q.weight=1),Q.opacity=P,i["stroke-linejoin"]&&(Q.joinstyle=i["stroke-linejoin"]||"miter"),Q.miterlimit=i["stroke-miterlimit"]||8,i["stroke-linecap"]&&(Q.endcap=i["stroke-linecap"]=="butt"?"flat":i["stroke-linecap"]=="square"?"square":"round");if(i["stroke-dasharray"]){var W={"-":"shortdash",".":"shortdot","-.":"shortdashdot","-..":"shortdashdotdot",". ":"dot","- ":"dash","--":"longdash","- .":"dashdot","--.":"longdashdot","--..":"longdashdotdot"};Q.dashstyle=W[b](i["stroke-dasharray"])?W[i["stroke-dasharray"]]:o}T&&l.appendChild(Q)}if(t.type=="text"){t.paper.canvas.style.display=o;var X=t.paper.span,Y=100,Z=m.font&&m.font.match(/\d+(?:\.\d*)?(?=px)/);p=X.style,m.font&&(p.font=m.font),m["font-family"]&&(p.fontFamily=m["font-family"]),m["font-weight"]&&(p.fontWeight=m["font-weight"]),m["font-style"]&&(p.fontStyle=m["font-style"]),Z=d(m["font-size"]||Z&&Z[0])||10,p.fontSize=Z*Y+"px",t.textpath.string&&(X.innerHTML=c(t.textpath.string).replace(/</g,"&#60;").replace(/&/g,"&#38;").replace(/\n/g,"<br>"));var $=X.getBoundingClientRect();t.W=m.w=($.right-$.left)/Y,t.H=m.h=($.bottom-$.top)/Y,t.X=m.x,t.Y=m.y+t.H/2,("x"in i||"y"in i)&&(t.path.v=a.format("m{0},{1}l{2},{1}",f(m.x*u),f(m.y*u),f(m.x*u)+1));var _=["x","y","text","font","font-family","font-weight","font-style","font-size"];for(var ba=0,bb=_.length;ba<bb;ba++)if(_[ba]in i){t._.dirty=1;break}switch(m["text-anchor"]){case"start":t.textpath.style["v-text-align"]="left",t.bbx=t.W/2;break;case"end":t.textpath.style["v-text-align"]="right",t.bbx=-t.W/2;break;default:t.textpath.style["v-text-align"]="center",t.bbx=0}t.textpath.style["v-text-kern"]=!0}},C=function(b,f,g){b.attrs=b.attrs||{};var h=b.attrs,i=Math.pow,j,k,l="linear",m=".5 .5";b.attrs.gradient=f,f=c(f).replace(a._radial_gradient,function(a,b,c){l="radial",b&&c&&(b=d(b),c=d(c),i(b-.5,2)+i(c-.5,2)>.25&&(c=e.sqrt(.25-i(b-.5,2))*((c>.5)*2-1)+.5),m=b+n+c);return o}),f=f.split(/\s*\-\s*/);if(l=="linear"){var p=f.shift();p=-d(p);if(isNaN(p))return null}var q=a._parseDots(f);if(!q)return null;b=b.shape||b.node;if(q.length){b.removeChild(g),g.on=!0,g.method="none",g.color=q[0].color,g.color2=q[q.length-1].color;var r=[];for(var s=0,t=q.length;s<t;s++)q[s].offset&&r.push(q[s].offset+n+q[s].color);g.colors=r.length?r.join():"0% "+g.color,l=="radial"?(g.type="gradientTitle",g.focus="100%",g.focussize="0 0",g.focusposition=m,g.angle=0):(g.type="gradient",g.angle=(270-p)%360),b.appendChild(g)}return 1},D=function(b,c){this[0]=this.node=b,b.raphael=!0,this.id=a._oid++,b.raphaelid=this.id,this.X=0,this.Y=0,this.attrs={},this.paper=c,this.matrix=a.matrix(),this._={transform:[],sx:1,sy:1,dx:0,dy:0,deg:0,dirty:1,dirtyT:1},!c.bottom&&(c.bottom=this),this.prev=c.top,c.top&&(c.top.next=this),c.top=this,this.next=null},E=a.el;D.prototype=E,E.constructor=D,E.transform=function(b){if(b==null)return this._.transform;var d=this.paper._viewBoxShift,e=d?"s"+[d.scale,d.scale]+"-1-1t"+[d.dx,d.dy]:o,f;d&&(f=b=c(b).replace(/\.{3}|\u2026/g,this._.transform||o)),a._extractTransform(this,e+b);var g=this.matrix.clone(),h=this.skew,i=this.node,j,k=~c(this.attrs.fill).indexOf("-"),l=!c(this.attrs.fill).indexOf("url(");g.translate(-0.5,-0.5);if(l||k||this.type=="image"){h.matrix="1 0 0 1",h.offset="0 0",j=g.split();if(k&&j.noRotation||!j.isSimple){i.style.filter=g.toFilter();var m=this.getBBox(),p=this.getBBox(1),q=m.x-p.x,r=m.y-p.y;i.coordorigin=q*-u+n+r*-u,z(this,1,1,q,r,0)}else i.style.filter=o,z(this,j.scalex,j.scaley,j.dx,j.dy,j.rotate)}else i.style.filter=o,h.matrix=c(g),h.offset=g.offset();f&&(this._.transform=f);return this},E.rotate=function(a,b,e){if(this.removed)return this;if(a!=null){a=c(a).split(k),a.length-1&&(b=d(a[1]),e=d(a[2])),a=d(a[0]),e==null&&(b=e);if(b==null||e==null){var f=this.getBBox(1);b=f.x+f.width/2,e=f.y+f.height/2}this._.dirtyT=1,this.transform(this._.transform.concat([["r",a,b,e]]));return this}},E.translate=function(a,b){if(this.removed)return this;a=c(a).split(k),a.length-1&&(b=d(a[1])),a=d(a[0])||0,b=+b||0,this._.bbox&&(this._.bbox.x+=a,this._.bbox.y+=b),this.transform(this._.transform.concat([["t",a,b]]));return this},E.scale=function(a,b,e,f){if(this.removed)return this;a=c(a).split(k),a.length-1&&(b=d(a[1]),e=d(a[2]),f=d(a[3]),isNaN(e)&&(e=null),isNaN(f)&&(f=null)),a=d(a[0]),b==null&&(b=a),f==null&&(e=f);if(e==null||f==null)var g=this.getBBox(1);e=e==null?g.x+g.width/2:e,f=f==null?g.y+g.height/2:f,this.transform(this._.transform.concat([["s",a,b,e,f]])),this._.dirtyT=1;return this},E.hide=function(){!this.removed&&(this.node.style.display="none");return this},E.show=function(){!this.removed&&(this.node.style.display=o);return this},E._getBBox=function(){if(this.removed)return{};return{x:this.X+(this.bbx||0)-this.W/2,y:this.Y-this.H,width:this.W,height:this.H}},E.remove=function(){if(!this.removed&&!!this.node.parentNode){this.paper.__set__&&this.paper.__set__.exclude(this),a.eve.unbind("raphael.*.*."+this.id),a._tear(this,this.paper),this.node.parentNode.removeChild(this.node),this.shape&&this.shape.parentNode.removeChild(this.shape);for(var b in this)this[b]=typeof this[b]=="function"?a._removedFactory(b):null;this.removed=!0}},E.attr=function(c,d){if(this.removed)return this;if(c==null){var e={};for(var f in this.attrs)this.attrs[b](f)&&(e[f]=this.attrs[f]);e.gradient&&e.fill=="none"&&(e.fill=e.gradient)&&delete e.gradient,e.transform=this._.transform;return e}if(d==null&&a.is(c,"string")){if(c==j&&this.attrs.fill=="none"&&this.attrs.gradient)return this.attrs.gradient;var g=c.split(k),h={};for(var i=0,m=g.length;i<m;i++)c=g[i],c in this.attrs?h[c]=this.attrs[c]:a.is(this.paper.customAttributes[c],"function")?h[c]=this.paper.customAttributes[c].def:h[c]=a._availableAttrs[c];return m-1?h:h[g[0]]}if(this.attrs&&d==null&&a.is(c,"array")){h={};for(i=0,m=c.length;i<m;i++)h[c[i]]=this.attr(c[i]);return h}var n;d!=null&&(n={},n[c]=d),d==null&&a.is(c,"object")&&(n=c);for(var o in n)l("raphael.attr."+o+"."+this.id,this,n[o]);if(n){for(o in this.paper.customAttributes)if(this.paper.customAttributes[b](o)&&n[b](o)&&a.is(this.paper.customAttributes[o],"function")){var p=this.paper.customAttributes[o].apply(this,[].concat(n[o]));this.attrs[o]=n[o];for(var q in p)p[b](q)&&(n[q]=p[q])}n.text&&this.type=="text"&&(this.textpath.string=n.text),B(this,n)}return this},E.toFront=function(){!this.removed&&this.node.parentNode.appendChild(this.node),this.paper&&this.paper.top!=this&&a._tofront(this,this.paper);return this},E.toBack=function(){if(this.removed)return this;this.node.parentNode.firstChild!=this.node&&(this.node.parentNode.insertBefore(this.node,this.node.parentNode.firstChild),a._toback(this,this.paper));return this},E.insertAfter=function(b){if(this.removed)return this;b.constructor==a.st.constructor&&(b=b[b.length-1]),b.node.nextSibling?b.node.parentNode.insertBefore(this.node,b.node.nextSibling):b.node.parentNode.appendChild(this.node),a._insertafter(this,b,this.paper);return this},E.insertBefore=function(b){if(this.removed)return this;b.constructor==a.st.constructor&&(b=b[0]),b.node.parentNode.insertBefore(this.node,b.node),a._insertbefore(this,b,this.paper);return this},E.blur=function(b){var c=this.node.runtimeStyle,d=c.filter;d=d.replace(r,o),+b!==0?(this.attrs.blur=b,c.filter=d+n+m+".Blur(pixelradius="+(+b||1.5)+")",c.margin=a.format("-{0}px 0 0 -{0}px",f(+b||1.5))):(c.filter=d,c.margin=0,delete this.attrs.blur)},a._engine.path=function(a,b){var c=F("shape");c.style.cssText=t,c.coordsize=u+n+u,c.coordorigin=b.coordorigin;var d=new D(c,b),e={fill:"none",stroke:"#000"};a&&(e.path=a),d.type="path",d.path=[],d.Path=o,B(d,e),b.canvas.appendChild(c);var f=F("skew");f.on=!0,c.appendChild(f),d.skew=f,d.transform(o);return d},a._engine.rect=function(b,c,d,e,f,g){var h=a._rectPath(c,d,e,f,g),i=b.path(h),j=i.attrs;i.X=j.x=c,i.Y=j.y=d,i.W=j.width=e,i.H=j.height=f,j.r=g,j.path=h,i.type="rect";return i},a._engine.ellipse=function(a,b,c,d,e){var f=a.path(),g=f.attrs;f.X=b-d,f.Y=c-e,f.W=d*2,f.H=e*2,f.type="ellipse",B(f,{cx:b,cy:c,rx:d,ry:e});return f},a._engine.circle=function(a,b,c,d){var e=a.path(),f=e.attrs;e.X=b-d,e.Y=c-d,e.W=e.H=d*2,e.type="circle",B(e,{cx:b,cy:c,r:d});return e},a._engine.image=function(b,c,d,e,f,g){var h=a._rectPath(d,e,f,g),i=b.path(h).attr({stroke:"none"}),k=i.attrs,l=i.node,m=l.getElementsByTagName(j)[0];k.src=c,i.X=k.x=d,i.Y=k.y=e,i.W=k.width=f,i.H=k.height=g,k.path=h,i.type="image",m.parentNode==l&&l.removeChild(m),m.rotate=!0,m.src=c,m.type="tile",i._.fillpos=[d,e],i._.fillsize=[f,g],l.appendChild(m),z(i,1,1,0,0,0);return i},a._engine.text=function(b,d,e,g){var h=F("shape"),i=F("path"),j=F("textpath");d=d||0,e=e||0,g=g||"",i.v=a.format("m{0},{1}l{2},{1}",f(d*u),f(e*u),f(d*u)+1),i.textpathok=!0,j.string=c(g),j.on=!0,h.style.cssText=t,h.coordsize=u+n+u,h.coordorigin="0 0";var k=new D(h,b),l={fill:"#000",stroke:"none",font:a._availableAttrs.font,text:g};k.shape=h,k.path=i,k.textpath=j,k.type="text",k.attrs.text=c(g),k.attrs.x=d,k.attrs.y=e,k.attrs.w=1,k.attrs.h=1,B(k,l),h.appendChild(j),h.appendChild(i),b.canvas.appendChild(h);var m=F("skew");m.on=!0,h.appendChild(m),k.skew=m,k.transform(o);return k},a._engine.setSize=function(b,c){var d=this.canvas.style;this.width=b,this.height=c,b==+b&&(b+="px"),c==+c&&(c+="px"),d.width=b,d.height=c,d.clip="rect(0 "+b+" "+c+" 0)",this._viewBox&&a._engine.setViewBox.apply(this,this._viewBox);return this},a._engine.setViewBox=function(b,c,d,e,f){a.eve("raphael.setViewBox",this,this._viewBox,[b,c,d,e,f]);var h=this.width,i=this.height,j=1/g(d/h,e/i),k,l;f&&(k=i/e,l=h/d,d*k<h&&(b-=(h-d*k)/2/k),e*l<i&&(c-=(i-e*l)/2/l)),this._viewBox=[b,c,d,e,!!f],this._viewBoxShift={dx:-b,dy:-c,scale:j},this.forEach(function(a){a.transform("...")});return this};var F;a._engine.initWin=function(a){var b=a.document;b.createStyleSheet().addRule(".rvml","behavior:url(#default#VML)");try{!b.namespaces.rvml&&b.namespaces.add("rvml","urn:schemas-microsoft-com:vml"),F=function(a){return b.createElement("<rvml:"+a+' class="rvml">')}}catch(c){F=function(a){return b.createElement("<"+a+' xmlns="urn:schemas-microsoft.com:vml" class="rvml">')}}},a._engine.initWin(a._g.win),a._engine.create=function(){var b=a._getContainer.apply(0,arguments),c=b.container,d=b.height,e,f=b.width,g=b.x,h=b.y;if(!c)throw new Error("VML container not found.");var i=new a._Paper,j=i.canvas=a._g.doc.createElement("div"),k=j.style;g=g||0,h=h||0,f=f||512,d=d||342,i.width=f,i.height=d,f==+f&&(f+="px"),d==+d&&(d+="px"),i.coordsize=u*1e3+n+u*1e3,i.coordorigin="0 0",i.span=a._g.doc.createElement("span"),i.span.style.cssText="position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;",j.appendChild(i.span),k.cssText=a.format("top:0;left:0;width:{0};height:{1};display:inline-block;position:relative;clip:rect(0 {0} {1} 0);overflow:hidden",f,d),c==1?(a._g.doc.body.appendChild(j),k.left=g+"px",k.top=h+"px",k.position="absolute"):c.firstChild?c.insertBefore(j,c.firstChild):c.appendChild(j),i.renderfix=function(){};return i},a.prototype.clear=function(){a.eve("raphael.clear",this),this.canvas.innerHTML=o,this.span=a._g.doc.createElement("span"),this.span.style.cssText="position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;display:inline;",this.canvas.appendChild(this.span),this.bottom=this.top=null},a.prototype.remove=function(){a.eve("raphael.remove",this),this.canvas.parentNode.removeChild(this.canvas);for(var b in this)this[b]=typeof this[b]=="function"?a._removedFactory(b):null;return!0};var G=a.st;for(var H in E)E[b](H)&&!G[b](H)&&(G[H]=function(a){return function(){var b=arguments;return this.forEach(function(c){c[a].apply(c,b)})}}(H))}(window.Raphael)
+'''
+
+background_jpg = '\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x02\x00\x00d\x00d\x00\x00\xff\xec\x00\x11Ducky\x00\x01\x00\x04\x00\x00\x00d\x00\x00\xff\xee\x00\x0eAdobe\x00d\xc0\x00\x00\x00\x01\xff\xdb\x00\x84\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x01\x01\x01\x01\x01\x01\x01\x02\x01\x01\x02\x02\x02\x01\x02\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\xff\xc0\x00\x11\x08\x03\x00\x00\n\x03\x01\x11\x00\x02\x11\x01\x03\x11\x01\xff\xc4\x00k\x00\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x02\x01\x04\t\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x06\x07\x10\x01\x00\x02\x01\x04\x01\x05\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x12Q\xf0\x11a\xa1q\x91\xd1\xe1\x02\x13\x81b\x11\x01\x01\x01\x01\x00\x03\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x01\x12!Qa\x02"\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11\x00?\x00\xf9\xc6\xf7\x0f\x9e\x80\x00\x0e\xb5\xc8\x1c\x8a\x8e`\x00\x00\x005\xb15\xa9\x86\xc4\xd2c\xad(\x00\x00\xe8\xb3@\x9a\xady\xe9nz^\x8a\xf3\xd1s\xd1\xd3H\xc8\x00\x00\xad</\x86\xae\x14\xf0x.6\x8c\x80\x00\n\xd25\x0b\xe1\xab\x9e\x8aF\xa0\xf0\\\xf4\xda2\x03\xa2\xcd\x02j\xd5\x8c-\xd2\xe9X\xc1t\xba\xea \x0e\xed8\x9fF\xa7\xd2\xe1\xb4\xe2}\t\xf4\xb8\xa8\xe6\x00\x006\xd3\xa0\x00\x00\xa5\'[7\xcf\xd5\xf0Ru\xb1\xcf\xd3\xc2\xaa\xc8\x0e\xed+5f\x9bI4\x9a\xb6\xd1\x88\x0b\xa6\xd1\x88\x0b\xae\xa2\x00\xb5c\x95\xabt\xacrR\xebH\x80)O\x1d\xaf\x85\xf0S\xc7g\x83\xc2\x88\x805Yjb\\+$\xc2\xe2\x83\x00;Y\xd6\xe4XVu\xb9\x08\xb8\x80;\xb4\xaf?\xa5\x9am\'?\xa2k\xd0\xda\x00m!4\xdaBj\xfbF .\x9bF .\xbaM@\x9a-X\xc1un\x95\x8c\x17K\xad\x00\x0bV\x16\xe9J\xc1t\xad \x02\xb4\x82\x85 \xa3`\x02\xbf\x9f=|\x9dg\xa7>\xcf\xcf\x9e\xbeN\xb3\xd1\xda\xac\xb9\x80\xa55\xa8_\x0b\xe0\xa6\xb5\x07\x83\xc2\x88\x80)\xf9\xf8u\x9f\x9fA\xf9\xf8\'\xe7\xd0\xaa\x005Ik\xc0RO\x02\xcc\x80;Y\xc4\xb53\xd8Vq$\xcfb\xec\x80\x0b5\x02h\xbe\xd1\x88\x16\xe9\xb4b\x02\xeb\xa4\xd4\t\xa3\xd1O\xae;\x9ft\xeb\\\xba\xfd\x14\xfa\xe3\xb9\xf7:\xd3\xaf\xd3H\xc8\n\xd22\xb7\xe1\xe0\xa4d\xbf\x0f\r\xa0\x03t\x9cw\x0e\x9c\xfe~\x85\'\x1d\xc1\xcf\xe7\xe8\xb0\x00,\xd4\t\xa2\xfbF#\xd0\xba\x1bF#\xd0\xba:\x8a\x02\x94\x9c\xc3W\x02\x93\x98.\n2\x005\xce\xa0s\xa2\xfbF!\x95\xbam\x18\x80\xba\xe8\x00\xd5\'\x1d\xc7\xbb_\xca\x14\x9cw\x1e\xe7\xf2,\xca\x80\x00\x0b\xfe_\xeb\xaf\x95\xef\xe34\xfc\xbf\xd7_\'\x7f\n\xb3\x9b \x0b7\xd6\x817\xd6\x8a\xd3\x9e\xbe]zB\x9c\xf5\xf2t(\xca\x80\x00\rW\xed\x8e\xe1\xbb\x88W\xed\x8e\xe0\xb8,\xc2\x80\x00\x03\\\xa0r+H\xe7_\xc3\xad\nG:\xfe\x1dh\xdb*\x00\x00\rs\xa8\x1c\xe8\xdd\'\x85\xeb\x02\x93\xc1\xd6\n\xb0\xa0?\xff\xd9'
+
diff --git a/kivy/modules/console.py b/kivy/modules/console.py
new file mode 100644
index 0000000..6d5c46f
--- /dev/null
+++ b/kivy/modules/console.py
@@ -0,0 +1,1059 @@
+# coding=utf-8
+"""
+Console
+=======
+
+.. versionadded:: 1.9.1
+
+Reboot of the old inspector, designed to be modular and keep concerns
+separated. It also has an addons architecture that allow you to add a button,
+panel, or more in the Console itself.
+
+.. warning::
+
+    This module works, but might fail in some cases. Please contribute!
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation::
+
+    python main.py -m console
+
+Mouse navigation
+----------------
+
+When the "Select" button is activated, you can:
+
+- tap once on a widget to select it without leaving inspect mode
+- double tap on a widget to select and leave inspect mode (then you can
+  manipulate the widget again)
+
+Keyboard navigation
+-------------------
+
+- "Ctrl + e": toggle console
+- "Escape": cancel widget lookup, then hide inspector view
+- "Up": select the parent widget
+- "Down": select the first child of the currently selected widget
+- "Left": select the previous sibling
+- "Right": select the next sibling
+
+Additional information
+----------------------
+
+Some properties can be edited live. However, due to the delayed usage of
+some properties, it might crash if you don't handle the required cases.
+
+Addons
+------
+
+Addons must be added to `Console.addons` before the first Clock tick of the
+application, or before :attr:`create_console` is called. You currently cannot
+add addons on the fly. Addons are quite cheap until the Console is activated.
+Panels are even cheaper as nothing is done until the user selects them.
+
+We provide multiple addons activated by default:
+
+- ConsoleAddonFps: display the FPS at the top-right
+- ConsoleAddonSelect: activate the selection mode
+- ConsoleAddonBreadcrumb: display the hierarchy of the current widget at the
+  bottom
+- ConsoleAddonWidgetTree: panel to display the widget tree of the application
+- ConsoleAddonWidgetPanel: panel to display the properties of the selected
+  widget
+
+If you need to add custom widgets in the Console, please use either
+:class:`ConsoleButton`, :class:`ConsoleToggleButton` or :class:`ConsoleLabel`.
+
+An addon must inherit from the :class:`ConsoleAddon` class.
+
+For example, here is a simple addon for displaying the FPS at the top/right
+of the Console::
+
+    from kivy.modules.console import Console, ConsoleAddon
+
+    class ConsoleAddonFps(ConsoleAddon):
+        def init(self):
+            self.lbl = ConsoleLabel(text="0 Fps")
+            self.console.add_toolbar_widget(self.lbl, right=True)
+
+        def activate(self):
+            self.event = Clock.schedule_interval(self.update_fps, 1 / 2.)
+
+        def deactivated(self):
+            self.event.cancel()
+
+        def update_fps(self, *args):
+            fps = Clock.get_fps()
+            self.lbl.text = "{} Fps".format(int(fps))
+
+    Console.register_addon(ConsoleAddonFps)
+
+
+You can create addons that add panels. Panel activation/deactivation is not
+tied to the addon activation/deactivation, but in some cases, you can use the
+same callback for deactivating the addon and the panel. Here is a simple
+"About" panel addon::
+
+    from kivy.modules.console import Console, ConsoleAddon, ConsoleLabel
+
+    class ConsoleAddonAbout(ConsoleAddon):
+        def init(self):
+            self.console.add_panel("About", self.panel_activate,
+                                   self.panel_deactivate)
+
+        def panel_activate(self):
+            self.console.bind(widget=self.update_content)
+            self.update_content()
+
+        def panel_deactivate(self):
+            self.console.unbind(widget=self.update_content)
+
+        def deactivate(self):
+            self.panel_deactivate()
+
+        def update_content(self, *args):
+            widget = self.console.widget
+            if not widget:
+                return
+            text = "Selected widget is: {!r}".format(widget)
+            lbl = ConsoleLabel(text=text)
+            self.console.set_content(lbl)
+
+    Console.register_addon(ConsoleAddonAbout)
+
+"""
+
+__all__ = ("start", "stop", "create_console", "Console", "ConsoleAddon",
+           "ConsoleButton", "ConsoleToggleButton", "ConsoleLabel")
+
+import kivy
+kivy.require('1.9.0')
+
+import weakref
+from functools import partial
+from itertools import chain
+from kivy.logger import Logger
+from kivy.uix.widget import Widget
+from kivy.uix.button import Button
+from kivy.uix.togglebutton import ToggleButton
+from kivy.uix.label import Label
+from kivy.uix.textinput import TextInput
+from kivy.uix.image import Image
+from kivy.uix.treeview import TreeViewNode, TreeView
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.relativelayout import RelativeLayout
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.modalview import ModalView
+from kivy.graphics import Color, Rectangle, PushMatrix, PopMatrix
+from kivy.graphics.context_instructions import Transform
+from kivy.graphics.transformation import Matrix
+from kivy.properties import (ObjectProperty, BooleanProperty, ListProperty,
+                             NumericProperty, StringProperty, OptionProperty,
+                             ReferenceListProperty, AliasProperty,
+                             VariableListProperty)
+from kivy.graphics.texture import Texture
+from kivy.clock import Clock
+from kivy.lang import Builder
+
+Builder.load_string("""
+<Console>:
+    size_hint: (1, None) if self.mode == "docked" else (None, None)
+    height: dp(250)
+
+    canvas:
+        Color:
+            rgb: .185, .18, .18
+        Rectangle:
+            size: self.size
+        Color:
+            rgb: .3, .3, .3
+        Rectangle:
+            pos: 0, self.height - dp(48)
+            size: self.width, dp(48)
+
+    GridLayout:
+        cols: 1
+        id: layout
+
+        GridLayout:
+            id: toolbar
+            rows: 1
+            height: "48dp"
+            size_hint_y: None
+            padding: "4dp"
+            spacing: "4dp"
+
+
+        RelativeLayout:
+            id: content
+
+
+<ConsoleAddonSeparator>:
+    size_hint_x: None
+    width: "10dp"
+
+<ConsoleButton,ConsoleToggleButton,ConsoleLabel>:
+    size_hint_x: None
+    width: self.texture_size[0] + dp(20)
+
+
+<ConsoleAddonBreadcrumbView>:
+    size_hint_y: None
+    height: "48dp"
+    canvas:
+        Color:
+            rgb: .3, .3, .3
+        Rectangle:
+            size: self.size
+    ScrollView:
+        id: sv
+        do_scroll_y: False
+        GridLayout:
+            id: stack
+            rows: 1
+            size_hint_x: None
+            width: self.minimum_width
+            padding: "4dp"
+            spacing: "4dp"
+
+<TreeViewProperty>:
+    height: max(dp(48), max(lkey.texture_size[1], ltext.texture_size[1]))
+    Label:
+        id: lkey
+        text: root.key
+        text_size: (self.width, None)
+        width: 150
+        size_hint_x: None
+    Label:
+        id: ltext
+        text: [repr(getattr(root.widget, root.key, '')), root.refresh][0]\
+                if root.widget else ''
+        text_size: (self.width, None)
+
+<ConsoleAddonWidgetTreeView>:
+    ScrollView:
+        scroll_type: ['bars', 'content']
+        bar_width: '10dp'
+
+        ConsoleAddonWidgetTreeImpl:
+            id: widgettree
+            hide_root: True
+            size_hint: None, None
+            height: self.minimum_height
+            width: max(self.parent.width, self.minimum_width)
+            selected_widget: root.widget
+            on_select_widget: root.console.highlight_widget(args[1])
+
+<-TreeViewWidget>:
+    height: self.texture_size[1] + sp(4)
+    size_hint_x: None
+    width: self.texture_size[0] + sp(4)
+
+    canvas.before:
+        Color:
+            rgba: self.color_selected if self.is_selected else (0, 0, 0, 0)
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        Color:
+            rgba: 1, 1, 1, int(not self.is_leaf)
+        Rectangle:
+            source:
+                ('atlas://data/images/defaulttheme/tree_%s' %
+                ('opened' if self.is_open else 'closed'))
+            size: 16, 16
+            pos: self.x - 20, self.center_y - 8
+
+    canvas:
+        Color:
+            rgba:
+                (self.disabled_color if self.disabled else
+                (self.color if not self.markup else (1, 1, 1, 1)))
+        Rectangle:
+            texture: self.texture
+            size: self.texture_size
+            pos:
+                (int(self.center_x - self.texture_size[0] / 2.),
+                int(self.center_y - self.texture_size[1] / 2.))
+
+""")
+
+
+def ignore_exception(f):
+    def f2(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except:
+            pass
+
+    return f2
+
+
+class TreeViewProperty(BoxLayout, TreeViewNode):
+    key = ObjectProperty(None, allownone=True)
+    refresh = BooleanProperty(False)
+    widget_ref = ObjectProperty(None, allownone=True)
+
+    def _get_widget(self):
+        wr = self.widget_ref
+        if wr is None:
+            return None
+        wr = wr()
+        if wr is None:
+            self.widget_ref = None
+            return None
+        return wr
+
+    widget = AliasProperty(_get_widget, None, bind=('widget_ref', ))
+
+
+class ConsoleButton(Button):
+    """Button specialized for the Console"""
+    pass
+
+
+class ConsoleToggleButton(ToggleButton):
+    """ToggleButton specialized for the Console"""
+    pass
+
+
+class ConsoleLabel(Label):
+    """LabelButton specialized for the Console"""
+    pass
+
+
+class ConsoleAddonSeparator(Widget):
+    pass
+
+
+class ConsoleAddon(object):
+    """Base class for implementing addons"""
+
+    #: Console instance
+    console = None
+
+    def __init__(self, console):
+        super(ConsoleAddon, self).__init__()
+        self.console = console
+        self.init()
+
+    def init(self):
+        """Method called when the addon is instantiated by the Console
+        """
+        pass
+
+    def activate(self):
+        """Method called when the addon is activated by the console
+        (when the console is displayed)"""
+        pass
+
+    def deactivate(self):
+        """Method called when the addon is deactivated by the console
+        (when the console is hidden)
+        """
+        pass
+
+
+class ConsoleAddonMode(ConsoleAddon):
+    def init(self):
+        btn = ConsoleToggleButton(text=u"Docked")
+        self.console.add_toolbar_widget(btn)
+
+
+class ConsoleAddonSelect(ConsoleAddon):
+    def init(self):
+        self.btn = ConsoleToggleButton(text=u"Select")
+        self.btn.bind(state=self.on_button_state)
+        self.console.add_toolbar_widget(self.btn)
+        self.console.bind(inspect_enabled=self.on_inspect_enabled)
+
+    def on_inspect_enabled(self, instance, value):
+        self.btn.state = "down" if value else "normal"
+
+    def on_button_state(self, instance, value):
+        self.console.inspect_enabled = (value == "down")
+
+
+class ConsoleAddonFps(ConsoleAddon):
+
+    _update_ev = None
+
+    def init(self):
+        self.lbl = ConsoleLabel(text="0 Fps")
+        self.console.add_toolbar_widget(self.lbl, right=True)
+
+    def activate(self):
+        ev = self._update_ev
+        if ev is None:
+            self._update_ev = Clock.schedule_interval(self.update_fps, 1 / 2.)
+        else:
+            ev()
+
+    def deactivated(self):
+        if self._update_ev is not None:
+            self._update_ev.cancel()
+
+    def update_fps(self, *args):
+        fps = Clock.get_fps()
+        self.lbl.text = "{} Fps".format(int(fps))
+
+
+class ConsoleAddonBreadcrumbView(RelativeLayout):
+    widget = ObjectProperty(None, allownone=True)
+    parents = []
+
+    def on_widget(self, instance, value):
+        stack = self.ids.stack
+
+        # determine if we can just highlight the current one
+        # or if we need to rebuild the breadcrumb
+        prefs = [btn.widget_ref() for btn in self.parents]
+        if value in prefs:
+            # ok, so just toggle this one instead.
+            index = prefs.index(value)
+            for btn in self.parents:
+                btn.state = "normal"
+            self.parents[index].state = "down"
+            return
+
+        # we need to rebuild the breadcrumb.
+        stack.clear_widgets()
+        if not value:
+            return
+        widget = value
+        parents = []
+        while True:
+            btn = ConsoleButton(text=widget.__class__.__name__)
+            btn.widget_ref = weakref.ref(widget)
+            btn.bind(on_release=self.highlight_widget)
+            parents.append(btn)
+            if widget == widget.parent:
+                break
+            widget = widget.parent
+        for btn in reversed(parents):
+            stack.add_widget(btn)
+        self.ids.sv.scroll_x = 1
+        self.parents = parents
+        btn.state = "down"
+
+    def highlight_widget(self, instance):
+        self.console.widget = instance.widget_ref()
+
+
+class ConsoleAddonBreadcrumb(ConsoleAddon):
+    def init(self):
+        self.view = ConsoleAddonBreadcrumbView()
+        self.view.console = self.console
+        self.console.ids.layout.add_widget(self.view)
+
+    def activate(self):
+        self.console.bind(widget=self.update_content)
+        self.update_content()
+
+    def deactivate(self):
+        self.console.unbind(widget=self.update_content)
+
+    def update_content(self, *args):
+        self.view.widget = self.console.widget
+
+
+class ConsoleAddonWidgetPanel(ConsoleAddon):
+    def init(self):
+        self.console.add_panel("Properties", self.panel_activate,
+                               self.deactivate)
+
+    def panel_activate(self):
+        self.console.bind(widget=self.update_content)
+        self.update_content()
+
+    def deactivate(self):
+        self.console.unbind(widget=self.update_content)
+
+    def update_content(self, *args):
+        widget = self.console.widget
+        if not widget:
+            return
+
+        from kivy.uix.scrollview import ScrollView
+        self.root = root = BoxLayout()
+        self.sv = sv = ScrollView(scroll_type=["bars", "content"],
+                                  bar_width='10dp')
+        treeview = TreeView(hide_root=True, size_hint_y=None)
+        treeview.bind(minimum_height=treeview.setter("height"))
+        keys = list(widget.properties().keys())
+        keys.sort()
+        node = None
+        wk_widget = weakref.ref(widget)
+        for key in keys:
+            node = TreeViewProperty(key=key, widget_ref=wk_widget)
+            node.bind(is_selected=self.show_property)
+            try:
+                widget.bind(**{
+                    key: partial(self.update_node_content, weakref.ref(node))
+                })
+            except:
+                pass
+            treeview.add_node(node)
+
+        root.add_widget(sv)
+        sv.add_widget(treeview)
+        self.console.set_content(root)
+
+    def show_property(self, instance, value, key=None, index=-1, *l):
+        # normal call: (tree node, focus, )
+        # nested call: (widget, prop value, prop key, index in dict/list)
+        if value is False:
+            return
+
+        console = self.console
+        content = None
+        if key is None:
+            # normal call
+            nested = False
+            widget = instance.widget
+            key = instance.key
+            prop = widget.property(key)
+            value = getattr(widget, key)
+        else:
+            # nested call, we might edit subvalue
+            nested = True
+            widget = instance
+            prop = None
+
+        dtype = None
+
+        if isinstance(prop, AliasProperty) or nested:
+            # trying to resolve type dynamically
+            if type(value) in (str, str):
+                dtype = 'string'
+            elif type(value) in (int, float):
+                dtype = 'numeric'
+            elif type(value) in (tuple, list):
+                dtype = 'list'
+
+        if isinstance(prop, NumericProperty) or dtype == 'numeric':
+            content = TextInput(text=str(value) or '', multiline=False)
+            content.bind(
+                text=partial(self.save_property_numeric, widget, key, index))
+
+        elif isinstance(prop, StringProperty) or dtype == 'string':
+            content = TextInput(text=value or '', multiline=True)
+            content.bind(
+                text=partial(self.save_property_text, widget, key, index))
+
+        elif (isinstance(prop, ListProperty) or
+              isinstance(prop, ReferenceListProperty) or
+              isinstance(prop, VariableListProperty) or dtype == 'list'):
+            content = GridLayout(cols=1, size_hint_y=None)
+            content.bind(minimum_height=content.setter('height'))
+            for i, item in enumerate(value):
+                button = Button(text=repr(item), size_hint_y=None, height=44)
+                if isinstance(item, Widget):
+                    button.bind(on_release=partial(console.highlight_widget,
+                                                   item, False))
+                else:
+                    button.bind(on_release=partial(self.show_property, widget,
+                                                   item, key, i))
+                content.add_widget(button)
+
+        elif isinstance(prop, OptionProperty):
+            content = GridLayout(cols=1, size_hint_y=None)
+            content.bind(minimum_height=content.setter('height'))
+            for option in prop.options:
+                button = ToggleButton(
+                    text=option,
+                    state='down' if option == value else 'normal',
+                    group=repr(content.uid),
+                    size_hint_y=None,
+                    height=44)
+                button.bind(
+                    on_press=partial(self.save_property_option, widget, key))
+                content.add_widget(button)
+
+        elif isinstance(prop, ObjectProperty):
+            if isinstance(value, Widget):
+                content = Button(text=repr(value))
+                content.bind(
+                    on_release=partial(console.highlight_widget, value))
+            elif isinstance(value, Texture):
+                content = Image(texture=value)
+            else:
+                content = Label(text=repr(value))
+
+        elif isinstance(prop, BooleanProperty):
+            state = 'down' if value else 'normal'
+            content = ToggleButton(text=key, state=state)
+            content.bind(on_release=partial(self.save_property_boolean, widget,
+                                            key, index))
+
+        self.root.clear_widgets()
+        self.root.add_widget(self.sv)
+        if content:
+            self.root.add_widget(content)
+
+    @ignore_exception
+    def save_property_numeric(self, widget, key, index, instance, value):
+        if index >= 0:
+            getattr(widget, key)[index] = float(instance.text)
+        else:
+            setattr(widget, key, float(instance.text))
+
+    @ignore_exception
+    def save_property_text(self, widget, key, index, instance, value):
+        if index >= 0:
+            getattr(widget, key)[index] = instance.text
+        else:
+            setattr(widget, key, instance.text)
+
+    @ignore_exception
+    def save_property_boolean(self, widget, key, index, instance, ):
+        value = instance.state == 'down'
+        if index >= 0:
+            getattr(widget, key)[index] = value
+        else:
+            setattr(widget, key, value)
+
+    @ignore_exception
+    def save_property_option(self, widget, key, instance, *l):
+        setattr(widget, key, instance.text)
+
+
+class TreeViewWidget(Label, TreeViewNode):
+    widget = ObjectProperty(None)
+
+
+class ConsoleAddonWidgetTreeImpl(TreeView):
+    selected_widget = ObjectProperty(None, allownone=True)
+
+    __events__ = ('on_select_widget', )
+
+    def __init__(self, **kwargs):
+        super(ConsoleAddonWidgetTreeImpl, self).__init__(**kwargs)
+        self.update_scroll = Clock.create_trigger(self._update_scroll)
+
+    def find_node_by_widget(self, widget):
+        for node in self.iterate_all_nodes():
+            if not node.parent_node:
+                continue
+            try:
+                if node.widget == widget:
+                    return node
+            except ReferenceError:
+                pass
+        return None
+
+    def update_selected_widget(self, widget):
+        if widget:
+            node = self.find_node_by_widget(widget)
+            if node:
+                self.select_node(node, False)
+                while node and isinstance(node, TreeViewWidget):
+                    if not node.is_open:
+                        self.toggle_node(node)
+                    node = node.parent_node
+
+    def on_selected_widget(self, inst, widget):
+        if widget:
+            self.update_selected_widget(widget)
+            self.update_scroll()
+
+    def select_node(self, node, select_widget=True):
+        super(ConsoleAddonWidgetTreeImpl, self).select_node(node)
+        if select_widget:
+            try:
+                self.dispatch("on_select_widget", node.widget.__self__)
+            except ReferenceError:
+                pass
+
+    def on_select_widget(self, widget):
+        pass
+
+    def _update_scroll(self, *args):
+        node = self._selected_node
+        if not node:
+            return
+
+        self.parent.scroll_to(node)
+
+
+class ConsoleAddonWidgetTreeView(RelativeLayout):
+    widget = ObjectProperty(None, allownone=True)
+    _window_node = None
+
+    def _update_widget_tree_node(self, node, widget, is_open=False):
+        tree = self.ids.widgettree
+        update_nodes = []
+        nodes = {}
+        for cnode in node.nodes[:]:
+            try:
+                nodes[cnode.widget] = cnode
+            except ReferenceError:
+                # widget no longer exists, just remove it
+                pass
+            tree.remove_node(cnode)
+        for child in widget.children:
+            if isinstance(child, Console):
+                continue
+            if child in nodes:
+                cnode = tree.add_node(nodes[child], node)
+            else:
+                cnode = tree.add_node(
+                    TreeViewWidget(text=child.__class__.__name__,
+                                   widget=child.proxy_ref,
+                                   is_open=is_open), node)
+            update_nodes.append((cnode, child))
+        return update_nodes
+
+    def update_widget_tree(self, *args):
+        win = self.console.win
+        if not self._window_node:
+            self._window_node = self.ids.widgettree.add_node(
+                TreeViewWidget(text="Window",
+                               widget=win,
+                               is_open=True))
+
+        nodes = self._update_widget_tree_node(self._window_node, win,
+                                              is_open=True)
+        while nodes:
+            ntmp = nodes[:]
+            nodes = []
+            for node in ntmp:
+                nodes += self._update_widget_tree_node(*node)
+
+        self.ids.widgettree.update_selected_widget(self.widget)
+
+
+class ConsoleAddonWidgetTree(ConsoleAddon):
+    def init(self):
+        self.content = None
+        self.console.add_panel("Tree", self.panel_activate, self.deactivate,
+                               self.panel_refresh)
+
+    def panel_activate(self):
+        self.console.bind(widget=self.update_content)
+        self.update_content()
+
+    def deactivate(self):
+        if self.content:
+            self.content.widget = None
+            self.content.console = None
+        self.console.unbind(widget=self.update_content)
+
+    def update_content(self, *args):
+        widget = self.console.widget
+        if not self.content:
+            self.content = ConsoleAddonWidgetTreeView()
+        self.content.console = self.console
+        self.content.widget = widget
+        self.content.update_widget_tree()
+        self.console.set_content(self.content)
+
+    def panel_refresh(self):
+        if self.content:
+            self.content.update_widget_tree()
+
+
+class Console(RelativeLayout):
+    """Console interface
+
+    This widget is created by create_console(), when the module is loaded.
+    During that time, you can add addons on the console to extend the
+    functionalities, or add your own application stats / debugging module.
+    """
+
+    #: Array of addons that will be created at Console creation
+    addons = [  # ConsoleAddonMode,
+        ConsoleAddonSelect, ConsoleAddonFps, ConsoleAddonWidgetPanel,
+        ConsoleAddonWidgetTree, ConsoleAddonBreadcrumb]
+
+    #: Display mode of the Console, either docked at the bottom, or as a
+    #: floating window.
+    mode = OptionProperty("docked", options=["docked", "floated"])
+
+    #: Current widget being selected
+    widget = ObjectProperty(None, allownone=True)
+
+    #: Indicate if the inspector inspection is enabled. If yes, the next
+    #: touch down will select a the widget under the touch
+    inspect_enabled = BooleanProperty(False)
+
+    #: True if the Console is activated (showed)
+    activated = BooleanProperty(False)
+
+    def __init__(self, **kwargs):
+        self.win = kwargs.pop('win', None)
+        super(Console, self).__init__(**kwargs)
+        self.avoid_bring_to_top = False
+        with self.canvas.before:
+            self.gcolor = Color(1, 0, 0, .25)
+            PushMatrix()
+            self.gtransform = Transform(Matrix())
+            self.grect = Rectangle(size=(0, 0))
+            PopMatrix()
+        Clock.schedule_interval(self.update_widget_graphics, 0)
+
+        # instantiate all addons
+        self._toolbar = {"left": [], "panels": [], "right": []}
+        self._addons = []
+        self._panel = None
+        for addon in self.addons:
+            instance = addon(self)
+            self._addons.append(instance)
+        self._init_toolbar()
+        # select the first panel
+        self._panel = self._toolbar["panels"][0]
+        self._panel.state = "down"
+        self._panel.cb_activate()
+
+    def _init_toolbar(self):
+        toolbar = self.ids.toolbar
+        for key in ("left", "panels", "right"):
+            if key == "right":
+                toolbar.add_widget(Widget())
+            for el in self._toolbar[key]:
+                toolbar.add_widget(el)
+            if key != "right":
+                toolbar.add_widget(ConsoleAddonSeparator())
+
+    @classmethod
+    def register_addon(cls, addon):
+        cls.addons.append(addon)
+
+    def add_toolbar_widget(self, widget, right=False):
+        """Add a widget in the top left toolbar of the Console.
+        Use `right=True` if you wanna add the widget at the right instead.
+        """
+        key = "right" if right else "left"
+        self._toolbar[key].append(widget)
+
+    def remove_toolbar_widget(self, widget):
+        """Remove a widget from the toolbar
+        """
+        self.ids.toolbar.remove_widget(widget)
+
+    def add_panel(self, name, cb_activate, cb_deactivate, cb_refresh=None):
+        """Add a new panel in the Console.
+
+        - `cb_activate` is a callable that will be called when the panel is
+          activated by the user.
+
+        - `cb_deactivate` is a callable that will be called when the panel is
+          deactivated or when the console will hide.
+
+        - `cb_refresh` is an optional callable that is called if the user
+          click again on the button for display the panel
+
+        When activated, it's up to the panel to display a content in the
+        Console by using :meth:`set_content`.
+        """
+        btn = ConsoleToggleButton(text=name)
+        btn.cb_activate = cb_activate
+        btn.cb_deactivate = cb_deactivate
+        btn.cb_refresh = cb_refresh
+        btn.bind(on_press=self._activate_panel)
+        self._toolbar["panels"].append(btn)
+
+    def _activate_panel(self, instance):
+        if self._panel != instance:
+            self._panel.cb_deactivate()
+            self._panel.state = "normal"
+            self.ids.content.clear_widgets()
+            self._panel = instance
+            self._panel.cb_activate()
+            self._panel.state = "down"
+        else:
+            self._panel.state = "down"
+            if self._panel.cb_refresh:
+                self._panel.cb_refresh()
+
+    def set_content(self, content):
+        """Replace the Console content with a new one.
+        """
+        self.ids.content.clear_widgets()
+        self.ids.content.add_widget(content)
+
+    def on_touch_down(self, touch):
+        ret = super(Console, self).on_touch_down(touch)
+        if (('button' not in touch.profile or touch.button == 'left') and
+                not ret and self.inspect_enabled):
+            self.highlight_at(*touch.pos)
+            if touch.is_double_tap:
+                self.inspect_enabled = False
+            ret = True
+        else:
+            ret = self.collide_point(*touch.pos)
+        return ret
+
+    def on_touch_move(self, touch):
+        ret = super(Console, self).on_touch_move(touch)
+        if not ret and self.inspect_enabled:
+            self.highlight_at(*touch.pos)
+            ret = True
+        return ret
+
+    def on_touch_up(self, touch):
+        ret = super(Console, self).on_touch_up(touch)
+        if not ret and self.inspect_enabled:
+            ret = True
+        return ret
+
+    def on_window_children(self, win, children):
+        if self.avoid_bring_to_top or not self.activated:
+            return
+        self.avoid_bring_to_top = True
+        win.remove_widget(self)
+        win.add_widget(self)
+        self.avoid_bring_to_top = False
+
+    def highlight_at(self, x, y):
+        """Select a widget from a x/y window coordinate.
+        This is mostly used internally when Select mode is activated
+        """
+        widget = None
+        # reverse the loop - look at children on top first and
+        # modalviews before others
+        win_children = self.win.children
+        children = chain((c for c in reversed(win_children)
+                          if isinstance(c, ModalView)),
+                         (c for c in reversed(win_children)
+                          if not isinstance(c, ModalView)))
+        for child in children:
+            if child is self:
+                continue
+            widget = self.pick(child, x, y)
+            if widget:
+                break
+        self.highlight_widget(widget)
+
+    def highlight_widget(self, widget, *largs):
+        # no widget to highlight, reduce rectangle to 0, 0
+        self.widget = widget
+        if not widget:
+            self.grect.size = 0, 0
+
+    def update_widget_graphics(self, *l):
+        if not self.activated:
+            return
+        if self.widget is None:
+            self.grect.size = 0, 0
+            return
+        self.grect.size = self.widget.size
+        matrix = self.widget.get_window_matrix()
+        if self.gtransform.matrix.get() != matrix.get():
+            self.gtransform.matrix = matrix
+
+    def pick(self, widget, x, y):
+        """Pick a widget at x/y, given a root `widget`
+        """
+        ret = None
+        # try to filter widgets that are not visible (invalid inspect target)
+        if (hasattr(widget, 'visible') and not widget.visible):
+            return ret
+        if widget.collide_point(x, y):
+            ret = widget
+            x2, y2 = widget.to_local(x, y)
+            # reverse the loop - look at children on top first
+            for child in reversed(widget.children):
+                ret = self.pick(child, x2, y2) or ret
+        return ret
+
+    def on_activated(self, instance, activated):
+        if activated:
+            self._activate_console()
+        else:
+            self._deactivate_console()
+
+    def _activate_console(self):
+        if self not in self.win.children:
+            self.win.add_widget(self)
+        self.y = 0
+        for addon in self._addons:
+            addon.activate()
+        Logger.info('Console: console activated')
+
+    def _deactivate_console(self):
+        for addon in self._addons:
+            addon.deactivate()
+        self.grect.size = 0, 0
+        self.y = -self.height
+        self.widget = None
+        self.inspect_enabled = False
+        # self.win.remove_widget(self)
+        self._window_node = None
+        Logger.info('Console: console deactivated')
+
+    def keyboard_shortcut(self, win, scancode, *largs):
+        modifiers = largs[-1]
+        if scancode == 101 and modifiers == ['ctrl']:
+            self.activated = not self.activated
+            if self.activated:
+                self.inspect_enabled = True
+            return True
+
+        elif scancode == 27:
+            if self.inspect_enabled:
+                self.inspect_enabled = False
+                return True
+            if self.activated:
+                self.activated = False
+                return True
+
+        if not self.activated or not self.widget:
+            return
+
+        if scancode == 273:  # top
+            self.widget = self.widget.parent
+
+        elif scancode == 274:  # down
+            filtered_children = [c for c in self.widget.children
+                                 if not isinstance(c, Console)]
+            if filtered_children:
+                self.widget = filtered_children[0]
+
+        elif scancode == 276:  # left
+            parent = self.widget.parent
+            filtered_children = [c for c in parent.children
+                                 if not isinstance(c, Console)]
+            index = filtered_children.index(self.widget)
+            index = max(0, index - 1)
+            self.widget = filtered_children[index]
+
+        elif scancode == 275:  # right
+            parent = self.widget.parent
+            filtered_children = [c for c in parent.children
+                                 if not isinstance(c, Console)]
+            index = filtered_children.index(self.widget)
+            index = min(len(filtered_children) - 1, index + 1)
+            self.widget = filtered_children[index]
+
+
+def create_console(win, ctx, *l):
+    ctx.console = Console(win=win)
+    win.bind(children=ctx.console.on_window_children,
+             on_keyboard=ctx.console.keyboard_shortcut)
+
+
+def start(win, ctx):
+    """Create an Console instance attached to the *ctx* and bound to the
+    Window's :meth:`~kivy.core.window.WindowBase.on_keyboard` event for
+    capturing the keyboard shortcut.
+
+        :Parameters:
+            `win`: A :class:`Window <kivy.core.window.WindowBase>`
+                The application Window to bind to.
+            `ctx`: A :class:`~kivy.uix.widget.Widget` or subclass
+                The Widget to be inspected.
+
+    """
+    Clock.schedule_once(partial(create_console, win, ctx))
+
+
+def stop(win, ctx):
+    """Stop and unload any active Inspectors for the given *ctx*."""
+    if hasattr(ctx, "console"):
+        win.unbind(children=ctx.console.on_window_children,
+                   on_keyboard=ctx.console.keyboard_shortcut)
+        win.remove_widget(ctx.console)
+        del ctx.console
diff --git a/kivy/modules/cursor.py b/kivy/modules/cursor.py
new file mode 100644
index 0000000..a0f1717
--- /dev/null
+++ b/kivy/modules/cursor.py
@@ -0,0 +1,75 @@
+'''
+Cursor
+======
+
+Shows a cursor following mouse motion events, useful on systems with no
+visible native mouse cursor.
+
+Configuration
+-------------
+
+:Parameters:
+    `texture`: str, defaults to
+        'data/images/cursor.png' Image used to represent the cursor if
+        displayed
+    `size`: tuple, defaults to (40, 40)
+        Apparent size of the mouse cursor, if displayed, (None,None) value
+        will keep its real size.
+    `offset`: tuple, defaults to (None, None)
+        Offset of the texture image. The default value will align the
+        top-left corner of the image to the mouse pos.
+
+Example
+-------
+
+In your configuration (`~/.kivy/config.ini`), you can add something like
+this::
+
+    [modules]
+    cursor = texture=mypointer.png,size=20x20,offset=20x20
+
+.. versionadded:: 1.10.0
+'''
+
+__all__ = ('start', 'stop')
+
+from kivy.core.image import Image
+from kivy.graphics import Color, Rectangle
+from kivy import kivy_data_dir
+from kivy.compat import string_types
+from os.path import join
+from functools import partial
+
+
+def _mouse_move(texture, size, offset, win, pos, *args):
+    if hasattr(win, '_cursor'):
+        c = win._cursor
+    else:
+        with win.canvas.after:
+            Color(1, 1, 1, 1, mode='rgba')
+            win._cursor = c = Rectangle(texture=texture, size=size)
+
+    c.pos = pos[0] + offset[0], pos[1] - size[1] + offset[1]
+
+
+def start(win, ctx):
+    cursor_texture = Image(
+        ctx.config.get('texture', join(kivy_data_dir, 'images', 'cursor.png'))
+    ).texture
+    cursor_size = ctx.config.get('size')
+    if isinstance(cursor_size, string_types):
+        cursor_size = [int(x) for x in cursor_size.split('x')]
+    elif not cursor_size:
+        cursor_size = cursor_texture.size
+
+    cursor_offset = ctx.config.get('offset', (0, 0))
+    if isinstance(cursor_offset, string_types):
+        cursor_offset = [int(x) for x in cursor_offset.split('x')]
+
+    win.bind(
+        mouse_pos=partial(
+            _mouse_move, cursor_texture, cursor_size, cursor_offset))
+
+
+def stop(win, ctx):
+    win.unbind(mouse_pos=_mouse_move)
diff --git a/kivy/modules/inspector.py b/kivy/modules/inspector.py
new file mode 100644
index 0000000..55026dd
--- /dev/null
+++ b/kivy/modules/inspector.py
@@ -0,0 +1,755 @@
+'''
+Inspector
+=========
+
+.. versionadded:: 1.0.9
+
+.. warning::
+
+    This module is highly experimental, use it with care.
+
+The Inspector is a tool for finding a widget in the widget tree by clicking or
+tapping on it.
+Some keyboard shortcuts are activated:
+
+    * "Ctrl + e": activate / deactivate the inspector view
+    * "Escape": cancel widget lookup first, then hide the inspector view
+
+Available inspector interactions:
+
+    * tap once on a widget to select it without leaving inspect mode
+    * double tap on a widget to select and leave inspect mode (then you can
+      manipulate the widget again)
+
+Some properties can be edited live. However, due to the delayed usage of
+some properties, it might crash if you don't handle all the cases.
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation.
+
+The Inspector, however, can also be imported and used just like a normal
+python module. This has the added advantage of being able to activate and
+deactivate the module programmatically::
+
+    from kivy.core.window import Window
+    from kivy.app import App
+    from kivy.uix.button import Button
+    from kivy.modules import inspector
+
+    class Demo(App):
+        def build(self):
+            button = Button(text="Test")
+            inspector.create_inspector(Window, button)
+            return button
+
+    Demo().run()
+
+To remove the Inspector, you can do the following::
+
+    inspector.stop(Window, button)
+
+'''
+
+__all__ = ('start', 'stop', 'create_inspector')
+
+import weakref
+from functools import partial
+from itertools import chain
+
+from kivy.animation import Animation
+from kivy.logger import Logger
+from kivy.graphics.transformation import Matrix
+from kivy.clock import Clock
+from kivy.lang import Builder
+from kivy.factory import Factory
+from kivy.weakproxy import WeakProxy
+from kivy.properties import (
+    ObjectProperty, BooleanProperty, ListProperty,
+    NumericProperty, StringProperty, OptionProperty,
+    ReferenceListProperty, AliasProperty, VariableListProperty
+)
+
+Builder.load_string('''
+<Inspector>:
+    layout: layout
+    widgettree: widgettree
+    treeview: treeview
+    content: content
+    BoxLayout:
+        orientation: 'vertical'
+        id: layout
+        size_hint_y: None
+        height: 250
+        padding: 5
+        spacing: 5
+        top: 0
+
+        canvas:
+            Color:
+                rgb: .4, .4, .4
+            Rectangle:
+                pos: self.x, self.top
+                size: self.width, 1
+            Color:
+                rgba: .185, .18, .18, .95
+            Rectangle:
+                pos: self.pos
+                size: self.size
+
+        # Top Bar
+        BoxLayout:
+            size_hint_y: None
+            height: 50
+            spacing: 5
+            Button:
+                text: 'Move to Top'
+                on_release: root.toggle_position(args[0])
+                size_hint_x: None
+                width: 120
+
+            ToggleButton:
+                text: 'Inspect'
+                on_state: root.inspect_enabled = args[1] == 'down'
+                size_hint_x: None
+                state: 'down' if root.inspect_enabled else 'normal'
+                width: 80
+
+            Button:
+                text: 'Parent'
+                on_release:
+                    root.highlight_widget(root.widget.parent) if root.widget \
+                            else None
+                size_hint_x: None
+                width: 80
+
+            Button:
+                text: '%r' % root.widget
+                on_release: root.show_widget_info()
+
+            Button:
+                text: 'X'
+                size_hint_x: None
+                width: 50
+                on_release: root.activated = False
+
+        # Bottom Bar
+        BoxLayout:
+            ScrollView:
+                scroll_type: ['bars', 'content']
+                bar_width: 10
+                size_hint_x: 0.0001
+
+                WidgetTree:
+                    id: widgettree
+                    hide_root: True
+                    size_hint: None, None
+                    height: self.minimum_height
+                    width: max(self.parent.width, self.minimum_width)
+                    selected_widget: root.widget
+                    on_select_widget: root.highlight_widget(args[1])
+
+            Splitter:
+                sizeable_from: 'left'
+                min_size: self.parent.width / 2
+                max_size: self.parent.width
+
+                BoxLayout:
+                    ScrollView:
+                        scroll_type: ['bars', 'content']
+                        bar_width: 10
+                        TreeView:
+                            id: treeview
+                            size_hint_y: None
+                            hide_root: True
+                            height: self.minimum_height
+
+                    Splitter:
+                        sizeable_from: 'left'
+                        keep_within_parent: True
+                        rescale_with_parent: True
+                        max_size: self.parent.width / 2
+                        min_size: 0
+
+                        ScrollView:
+                            id: content
+
+<TreeViewProperty>:
+    height: max(lkey.texture_size[1], ltext.texture_size[1])
+    Label:
+        id: lkey
+        text: root.key
+        text_size: (self.width, None)
+        width: 150
+        size_hint_x: None
+    Label:
+        id: ltext
+        text: [repr(getattr(root.widget, root.key, '')), root.refresh][0]\
+                if root.widget else ''
+        text_size: (self.width, None)
+
+<-TreeViewWidget>:
+    height: self.texture_size[1] + sp(4)
+    size_hint_x: None
+    width: self.texture_size[0] + sp(4)
+
+    canvas.before:
+        Color:
+            rgba: self.color_selected if self.is_selected else (0, 0, 0, 0)
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        Color:
+            rgba: 1, 1, 1, int(not self.is_leaf)
+        Rectangle:
+            source:
+                ('atlas://data/images/defaulttheme/tree_%s' %
+                ('opened' if self.is_open else 'closed'))
+            size: 16, 16
+            pos: self.x - 20, self.center_y - 8
+
+    canvas:
+        Color:
+            rgba:
+                (self.disabled_color if self.disabled else
+                (self.color if not self.markup else (1, 1, 1, 1)))
+        Rectangle:
+            texture: self.texture
+            size: self.texture_size
+            pos:
+                (int(self.center_x - self.texture_size[0] / 2.),
+                int(self.center_y - self.texture_size[1] / 2.))
+''')
+
+
+class TreeViewProperty(Factory.BoxLayout, Factory.TreeViewNode):
+
+    widget_ref = ObjectProperty(None, allownone=True)
+
+    def _get_widget(self):
+        wr = self.widget_ref
+        if wr is None:
+            return
+        wr = wr()
+        if wr is None:
+            self.widget_ref = None
+            return
+        return wr
+    widget = AliasProperty(_get_widget, None, bind=('widget_ref', ))
+
+    key = ObjectProperty(None, allownone=True)
+
+    inspector = ObjectProperty(None)
+
+    refresh = BooleanProperty(False)
+
+
+class TreeViewWidget(Factory.Label, Factory.TreeViewNode):
+    widget = ObjectProperty(None)
+
+
+class WidgetTree(Factory.TreeView):
+    selected_widget = ObjectProperty(None, allownone=True)
+
+    __events__ = ('on_select_widget',)
+
+    def __init__(self, **kwargs):
+        super(WidgetTree, self).__init__(**kwargs)
+        self.update_scroll = Clock.create_trigger(self._update_scroll)
+
+    def find_node_by_widget(self, widget):
+        for node in self.iterate_all_nodes():
+            if not node.parent_node:
+                continue
+            try:
+                if node.widget == widget:
+                    return node
+            except ReferenceError:
+                pass
+        return
+
+    def update_selected_widget(self, widget):
+        if widget:
+            node = self.find_node_by_widget(widget)
+            if node:
+                self.select_node(node, False)
+                while node and isinstance(node, TreeViewWidget):
+                    if not node.is_open:
+                        self.toggle_node(node)
+                    node = node.parent_node
+
+    def on_selected_widget(self, inst, widget):
+        if widget:
+            self.update_selected_widget(widget)
+            self.update_scroll()
+
+    def select_node(self, node, select_widget=True):
+        super(WidgetTree, self).select_node(node)
+        if select_widget:
+            try:
+                self.dispatch('on_select_widget', node.widget.__self__)
+            except ReferenceError:
+                pass
+
+    def on_select_widget(self, widget):
+        pass
+
+    def _update_scroll(self, *args):
+        node = self._selected_node
+        if not node:
+            return
+
+        self.parent.scroll_to(node)
+
+
+class Inspector(Factory.FloatLayout):
+
+    widget = ObjectProperty(None, allownone=True)
+
+    layout = ObjectProperty(None)
+
+    widgettree = ObjectProperty(None)
+
+    treeview = ObjectProperty(None)
+
+    inspect_enabled = BooleanProperty(False)
+
+    activated = BooleanProperty(False)
+
+    widget_info = BooleanProperty(False)
+
+    content = ObjectProperty(None)
+
+    at_bottom = BooleanProperty(True)
+
+    _update_widget_tree_ev = None
+
+    def __init__(self, **kwargs):
+        self.win = kwargs.pop('win', None)
+        super(Inspector, self).__init__(**kwargs)
+        self.avoid_bring_to_top = False
+        with self.canvas.before:
+            self.gcolor = Factory.Color(1, 0, 0, .25)
+            Factory.PushMatrix()
+            self.gtransform = Factory.Transform(Matrix())
+            self.grect = Factory.Rectangle(size=(0, 0))
+            Factory.PopMatrix()
+        Clock.schedule_interval(self.update_widget_graphics, 0)
+
+    def on_touch_down(self, touch):
+        ret = super(Inspector, self).on_touch_down(touch)
+        if (('button' not in touch.profile or touch.button == 'left') and
+                not ret and self.inspect_enabled):
+            self.highlight_at(*touch.pos)
+            if touch.is_double_tap:
+                self.inspect_enabled = False
+                self.show_widget_info()
+            ret = True
+        return ret
+
+    def on_touch_move(self, touch):
+        ret = super(Inspector, self).on_touch_move(touch)
+        if not ret and self.inspect_enabled:
+            self.highlight_at(*touch.pos)
+            ret = True
+        return ret
+
+    def on_touch_up(self, touch):
+        ret = super(Inspector, self).on_touch_up(touch)
+        if not ret and self.inspect_enabled:
+            ret = True
+        return ret
+
+    def on_window_children(self, win, children):
+        if self.avoid_bring_to_top or not self.activated:
+            return
+        self.avoid_bring_to_top = True
+        win.remove_widget(self)
+        win.add_widget(self)
+        self.avoid_bring_to_top = False
+
+    def highlight_at(self, x, y):
+        widget = None
+        # reverse the loop - look at children on top first and
+        # modalviews before others
+        win_children = self.win.children
+        children = chain(
+            (c for c in win_children if isinstance(c, Factory.ModalView)),
+            (
+                c for c in reversed(win_children)
+                if not isinstance(c, Factory.ModalView)
+            )
+        )
+        for child in children:
+            if child is self:
+                continue
+            widget = self.pick(child, x, y)
+            if widget:
+                break
+        self.highlight_widget(widget)
+
+    def highlight_widget(self, widget, info=True, *largs):
+        # no widget to highlight, reduce rectangle to 0, 0
+        self.widget = widget
+        if not widget:
+            self.grect.size = 0, 0
+        if self.widget_info and info:
+            self.show_widget_info()
+
+    def update_widget_graphics(self, *largs):
+        if not self.activated:
+            return
+        if self.widget is None:
+            self.grect.size = 0, 0
+            return
+        self.grect.size = self.widget.size
+        matrix = self.widget.get_window_matrix()
+        if self.gtransform.matrix.get() != matrix.get():
+            self.gtransform.matrix = matrix
+
+    def toggle_position(self, button):
+        to_bottom = button.text == 'Move to Bottom'
+
+        if to_bottom:
+            button.text = 'Move to Top'
+            if self.widget_info:
+                Animation(top=250, t='out_quad', d=.3).start(self.layout)
+            else:
+                Animation(top=60, t='out_quad', d=.3).start(self.layout)
+
+            bottom_bar = self.layout.children[1]
+            self.layout.remove_widget(bottom_bar)
+            self.layout.add_widget(bottom_bar)
+        else:
+            button.text = 'Move to Bottom'
+            if self.widget_info:
+                Animation(top=self.height, t='out_quad', d=.3).start(
+                    self.layout)
+            else:
+                Animation(y=self.height - 60, t='out_quad', d=.3).start(
+                    self.layout)
+
+            bottom_bar = self.layout.children[1]
+            self.layout.remove_widget(bottom_bar)
+            self.layout.add_widget(bottom_bar)
+        self.at_bottom = to_bottom
+
+    def pick(self, widget, x, y):
+        ret = None
+        # try to filter widgets that are not visible (invalid inspect target)
+        if (hasattr(widget, 'visible') and not widget.visible):
+            return ret
+        if widget.collide_point(x, y):
+            ret = widget
+            x2, y2 = widget.to_local(x, y)
+            # reverse the loop - look at children on top first
+            for child in reversed(widget.children):
+                ret = self.pick(child, x2, y2) or ret
+        return ret
+
+    def on_activated(self, instance, activated):
+        if not activated:
+            self.grect.size = 0, 0
+            if self.at_bottom:
+                anim = Animation(top=0, t='out_quad', d=.3)
+            else:
+                anim = Animation(y=self.height, t='out_quad', d=.3)
+            anim.bind(on_complete=self.animation_close)
+            anim.start(self.layout)
+            self.widget = None
+            self.widget_info = False
+        else:
+            self.win.add_widget(self)
+            Logger.info('Inspector: inspector activated')
+            if self.at_bottom:
+                Animation(top=60, t='out_quad', d=.3).start(self.layout)
+            else:
+                Animation(y=self.height - 60, t='out_quad', d=.3).start(
+                    self.layout)
+            ev = self._update_widget_tree_ev
+            if ev is None:
+                ev = self._update_widget_tree_ev = Clock.schedule_interval(
+                    self.update_widget_tree, 1)
+            else:
+                ev()
+            self.update_widget_tree()
+
+    def animation_close(self, instance, value):
+        if not self.activated:
+            self.inspect_enabled = False
+            self.win.remove_widget(self)
+            self.content.clear_widgets()
+            treeview = self.treeview
+            for node in list(treeview.iterate_all_nodes()):
+                node.widget_ref = None
+                treeview.remove_node(node)
+
+            self._window_node = None
+            if self._update_widget_tree_ev is not None:
+                self._update_widget_tree_ev.cancel()
+
+            widgettree = self.widgettree
+            for node in list(widgettree.iterate_all_nodes()):
+                widgettree.remove_node(node)
+            Logger.info('Inspector: inspector deactivated')
+
+    def show_widget_info(self):
+        self.content.clear_widgets()
+        widget = self.widget
+        treeview = self.treeview
+        for node in list(treeview.iterate_all_nodes())[:]:
+            node.widget_ref = None
+            treeview.remove_node(node)
+        if not widget:
+            if self.at_bottom:
+                Animation(top=60, t='out_quad', d=.3).start(self.layout)
+            else:
+                Animation(y=self.height - 60, t='out_quad', d=.3).start(
+                    self.layout)
+            self.widget_info = False
+            return
+        self.widget_info = True
+        if self.at_bottom:
+            Animation(top=250, t='out_quad', d=.3).start(self.layout)
+        else:
+            Animation(top=self.height, t='out_quad', d=.3).start(self.layout)
+        for node in list(treeview.iterate_all_nodes())[:]:
+            treeview.remove_node(node)
+
+        keys = list(widget.properties().keys())
+        keys.sort()
+        node = None
+        if type(widget) is WeakProxy:
+            wk_widget = widget.__ref__
+        else:
+            wk_widget = weakref.ref(widget)
+        for key in keys:
+            node = TreeViewProperty(key=key, widget_ref=wk_widget)
+            node.bind(is_selected=self.show_property)
+            try:
+                widget.bind(**{key: partial(
+                    self.update_node_content, weakref.ref(node))})
+            except:
+                pass
+            treeview.add_node(node)
+
+    def update_node_content(self, node, *largs):
+        node = node()
+        if node is None:
+            return
+        node.refresh = True
+        node.refresh = False
+
+    def keyboard_shortcut(self, win, scancode, *largs):
+        modifiers = largs[-1]
+        if scancode == 101 and set(modifiers) & {'ctrl'} and not set(
+                modifiers) & {'shift', 'alt', 'meta'}:
+            self.activated = not self.activated
+            if self.activated:
+                self.inspect_enabled = True
+            return True
+        elif scancode == 27:
+            if self.inspect_enabled:
+                self.inspect_enabled = False
+                return True
+            if self.activated:
+                self.activated = False
+                return True
+
+    def show_property(self, instance, value, key=None, index=-1, *largs):
+        # normal call: (tree node, focus, )
+        # nested call: (widget, prop value, prop key, index in dict/list)
+        if value is False:
+            return
+
+        content = None
+        if key is None:
+            # normal call
+            nested = False
+            widget = instance.widget
+            key = instance.key
+            prop = widget.property(key)
+            value = getattr(widget, key)
+        else:
+            # nested call, we might edit subvalue
+            nested = True
+            widget = instance
+            prop = None
+
+        dtype = None
+
+        if isinstance(prop, AliasProperty) or nested:
+            # trying to resolve type dynamically
+            if type(value) in (str, str):
+                dtype = 'string'
+            elif type(value) in (int, float):
+                dtype = 'numeric'
+            elif type(value) in (tuple, list):
+                dtype = 'list'
+
+        if isinstance(prop, NumericProperty) or dtype == 'numeric':
+            content = Factory.TextInput(text=str(value) or '', multiline=False)
+            content.bind(text=partial(
+                self.save_property_numeric, widget, key, index))
+        elif isinstance(prop, StringProperty) or dtype == 'string':
+            content = Factory.TextInput(text=value or '', multiline=True)
+            content.bind(text=partial(
+                self.save_property_text, widget, key, index))
+        elif (isinstance(prop, ListProperty) or
+              isinstance(prop, ReferenceListProperty) or
+              isinstance(prop, VariableListProperty) or
+              dtype == 'list'):
+            content = Factory.GridLayout(cols=1, size_hint_y=None)
+            content.bind(minimum_height=content.setter('height'))
+            for i, item in enumerate(value):
+                button = Factory.Button(
+                    text=repr(item),
+                    size_hint_y=None,
+                    height=44
+                )
+                if isinstance(item, Factory.Widget):
+                    button.bind(on_release=partial(self.highlight_widget, item,
+                                                   False))
+                else:
+                    button.bind(on_release=partial(self.show_property, widget,
+                                                   item, key, i))
+                content.add_widget(button)
+        elif isinstance(prop, OptionProperty):
+            content = Factory.GridLayout(cols=1, size_hint_y=None)
+            content.bind(minimum_height=content.setter('height'))
+            for option in prop.options:
+                button = Factory.ToggleButton(
+                    text=option,
+                    state='down' if option == value else 'normal',
+                    group=repr(content.uid), size_hint_y=None,
+                    height=44)
+                button.bind(on_press=partial(
+                    self.save_property_option, widget, key))
+                content.add_widget(button)
+        elif isinstance(prop, ObjectProperty):
+            if isinstance(value, Factory.Widget):
+                content = Factory.Button(text=repr(value))
+                content.bind(on_release=partial(self.highlight_widget, value))
+            elif isinstance(value, Factory.Texture):
+                content = Factory.Image(texture=value)
+            else:
+                content = Factory.Label(text=repr(value))
+
+        elif isinstance(prop, BooleanProperty):
+            state = 'down' if value else 'normal'
+            content = Factory.ToggleButton(text=key, state=state)
+            content.bind(on_release=partial(self.save_property_boolean, widget,
+                                            key, index))
+
+        self.content.clear_widgets()
+        if content:
+            self.content.add_widget(content)
+
+    def save_property_numeric(self, widget, key, index, instance, value):
+        try:
+            if index >= 0:
+                getattr(widget, key)[index] = float(instance.text)
+            else:
+                setattr(widget, key, float(instance.text))
+        except:
+            pass
+
+    def save_property_text(self, widget, key, index, instance, value):
+        try:
+            if index >= 0:
+                getattr(widget, key)[index] = instance.text
+            else:
+                setattr(widget, key, instance.text)
+        except:
+            pass
+
+    def save_property_boolean(self, widget, key, index, instance, ):
+        try:
+            value = instance.state == 'down'
+            if index >= 0:
+                getattr(widget, key)[index] = value
+            else:
+                setattr(widget, key, value)
+        except:
+            pass
+
+    def save_property_option(self, widget, key, instance, *largs):
+        try:
+            setattr(widget, key, instance.text)
+        except:
+            pass
+
+    def _update_widget_tree_node(self, node, widget, is_open=False):
+        tree = self.widgettree
+        update_nodes = []
+        nodes = {}
+        for cnode in node.nodes[:]:
+            try:
+                nodes[cnode.widget] = cnode
+            except ReferenceError:
+                # widget no longer exists, just remove it
+                pass
+            tree.remove_node(cnode)
+        for child in widget.children:
+            if child is self:
+                continue
+            if child in nodes:
+                cnode = tree.add_node(nodes[child], node)
+            else:
+                cnode = tree.add_node(TreeViewWidget(
+                    text=child.__class__.__name__, widget=child.proxy_ref,
+                    is_open=is_open), node)
+            update_nodes.append((cnode, child))
+        return update_nodes
+
+    def update_widget_tree(self, *args):
+        if not hasattr(self, '_window_node') or not self._window_node:
+            self._window_node = self.widgettree.add_node(
+                TreeViewWidget(text='Window', widget=self.win, is_open=True))
+
+        nodes = self._update_widget_tree_node(self._window_node, self.win,
+                                              is_open=True)
+        while nodes:
+            ntmp = nodes[:]
+            nodes = []
+            for node in ntmp:
+                nodes += self._update_widget_tree_node(*node)
+
+        self.widgettree.update_selected_widget(self.widget)
+
+
+def create_inspector(win, ctx, *largs):
+    '''Create an Inspector instance attached to the *ctx* and bound to the
+    Window's :meth:`~kivy.core.window.WindowBase.on_keyboard` event for
+    capturing the keyboard shortcut.
+
+        :Parameters:
+            `win`: A :class:`Window <kivy.core.window.WindowBase>`
+                The application Window to bind to.
+            `ctx`: A :class:`~kivy.uix.widget.Widget` or subclass
+                The Widget to be inspected.
+
+    '''
+    # Dunno why, but if we are creating inspector within the start(), no lang
+    # rules are applied.
+    ctx.inspector = Inspector(win=win)
+    win.bind(children=ctx.inspector.on_window_children,
+             on_keyboard=ctx.inspector.keyboard_shortcut)
+
+
+def start(win, ctx):
+    ctx.ev_late_create = Clock.schedule_once(
+        partial(create_inspector, win, ctx))
+
+
+def stop(win, ctx):
+    '''Stop and unload any active Inspectors for the given *ctx*.'''
+    if hasattr(ctx, 'ev_late_create'):
+        ctx.ev_late_create.cancel()
+        del ctx.ev_late_create
+    if hasattr(ctx, 'inspector'):
+        win.unbind(children=ctx.inspector.on_window_children,
+                   on_keyboard=ctx.inspector.keyboard_shortcut)
+        win.remove_widget(ctx.inspector)
+        del ctx.inspector
diff --git a/kivy/modules/joycursor.py b/kivy/modules/joycursor.py
new file mode 100644
index 0000000..3602e3d
--- /dev/null
+++ b/kivy/modules/joycursor.py
@@ -0,0 +1,299 @@
+'''
+JoyCursor
+=========
+
+.. versionadded:: 1.10.0
+
+The JoyCursor is a tool for navigating with a joystick as if using a mouse
+or touch. Most of the actions that are possible for a mouse user are available
+in this module.
+
+For example:
+
+    * left click
+    * right click
+    * double click (two clicks)
+    * moving the cursor
+    * holding the button (+ moving at the same time)
+    * selecting
+    * scrolling
+
+There are some properties that can be edited live, such as intensity of the
+JoyCursor movement and toggling mouse button holding.
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation
+and these bindings:
+
++------------------+--------------------+
+| Event            | Joystick           |
++==================+====================+
+| cursor move      | Axis 3, Axis 4     |
++------------------+--------------------+
+| cursor intensity | Button 0, Button 1 |
++------------------+--------------------+
+| left click       | Button 2           |
++------------------+--------------------+
+| right click      | Button 3           |
++------------------+--------------------+
+| scroll up        | Button 4           |
++------------------+--------------------+
+| scroll down      | Button 5           |
++------------------+--------------------+
+| hold button      | Button 6           |
++------------------+--------------------+
+| joycursor on/off | Button 7           |
++------------------+--------------------+
+
+The JoyCursor, like Inspector, can also be imported and used as a normal
+python module. This has the added advantage of being able to activate and
+deactivate the module programmatically::
+
+    from kivy.lang import Builder
+    from kivy.base import runTouchApp
+    runTouchApp(Builder.load_string("""
+    #:import jc kivy.modules.joycursor
+    BoxLayout:
+        Button:
+            text: 'Press & activate with Ctrl+E or Button 7'
+            on_release: jc.create_joycursor(root.parent, root)
+        Button:
+            text: 'Disable'
+            on_release: jc.stop(root.parent, root)
+    """))
+'''
+
+__all__ = ('start', 'stop', 'create_joycursor')
+
+from kivy.clock import Clock
+from kivy.logger import Logger
+from kivy.uix.widget import Widget
+from kivy.graphics import Color, Line
+from kivy.properties import (
+    ObjectProperty,
+    NumericProperty,
+    BooleanProperty
+)
+
+
+class JoyCursor(Widget):
+    win = ObjectProperty()
+    activated = BooleanProperty(False)
+    cursor_width = NumericProperty(1.1)
+    cursor_hold = BooleanProperty(False)
+    intensity = NumericProperty(4)
+    dead_zone = NumericProperty(10000)
+    offset_x = NumericProperty(0)
+    offset_y = NumericProperty(0)
+
+    def __init__(self, **kwargs):
+        super(JoyCursor, self).__init__(**kwargs)
+        self.avoid_bring_to_top = False
+        self.size_hint = (None, None)
+        self.size = (21, 21)
+        self.set_cursor()
+
+        # draw cursor
+        with self.canvas:
+            Color(rgba=(0.19, 0.64, 0.81, 0.5))
+            self.cursor_ox = Line(
+                points=self.cursor_pts[:4],
+                width=self.cursor_width + 0.1
+            )
+            self.cursor_oy = Line(
+                points=self.cursor_pts[4:],
+                width=self.cursor_width + 0.1
+            )
+            Color(rgba=(1, 1, 1, 0.5))
+            self.cursor_x = Line(
+                points=self.cursor_pts[:4],
+                width=self.cursor_width
+            )
+            self.cursor_y = Line(
+                points=self.cursor_pts[4:],
+                width=self.cursor_width
+            )
+        self.pos = [-i for i in self.size]
+
+    def on_window_children(self, win, *args):
+        # pull JoyCursor to the front when added
+        # as a child directly to the window.
+        if self.avoid_bring_to_top or not self.activated:
+            return
+        self.avoid_bring_to_top = True
+        win.remove_widget(self)
+        win.add_widget(self)
+        self.avoid_bring_to_top = False
+
+    def on_activated(self, instance, activated):
+        # bind/unbind when JoyCursor's state is changed
+        if activated:
+            self.win.add_widget(self)
+            self.move = Clock.schedule_interval(self.move_cursor, 0)
+            self.win.fbind('on_joy_axis', self.check_cursor)
+            self.win.fbind('on_joy_button_down', self.set_intensity)
+            self.win.fbind('on_joy_button_down', self.check_dispatch)
+            self.win.fbind('mouse_pos', self.stop_cursor)
+            mouse_pos = self.win.mouse_pos
+            self.pos = (
+                mouse_pos[0] - self.size[0] / 2.0,
+                mouse_pos[1] - self.size[1] / 2.0
+            )
+            Logger.info('JoyCursor: joycursor activated')
+        else:
+            self.pos = [-i for i in self.size]
+            Clock.unschedule(self.move)
+            self.win.funbind('on_joy_axis', self.check_cursor)
+            self.win.funbind('on_joy_button_down', self.set_intensity)
+            self.win.funbind('on_joy_button_down', self.check_dispatch)
+            self.win.funbind('mouse_pos', self.stop_cursor)
+            self.win.remove_widget(self)
+            Logger.info('JoyCursor: joycursor deactivated')
+
+    def set_cursor(self, *args):
+        # create cursor points
+        px, py = self.pos
+        sx, sy = self.size
+        self.cursor_pts = [
+            px, py + round(sy / 2.0), px + sx, py + round(sy / 2.0),
+            px + round(sx / 2.0), py, px + round(sx / 2.0), py + sy
+        ]
+
+    def check_cursor(self, win, stickid, axisid, value):
+        # check axes and set offset if a movement is registered
+        intensity = self.intensity
+        dead = self.dead_zone
+
+        if axisid == 3:
+            if value < -dead:
+                self.offset_x = -intensity
+            elif value > dead:
+                self.offset_x = intensity
+            else:
+                self.offset_x = 0
+        elif axisid == 4:
+            # invert Y axis to behave like mouse
+            if value < -dead:
+                self.offset_y = intensity
+            elif value > dead:
+                self.offset_y = -intensity
+            else:
+                self.offset_y = 0
+        else:
+            self.offset_x = 0
+            self.offset_y = 0
+
+    def set_intensity(self, win, stickid, buttonid):
+        # set intensity of joycursor with joystick buttons
+        intensity = self.intensity
+        if buttonid == 0 and intensity > 2:
+            intensity -= 1
+        elif buttonid == 1:
+            intensity += 1
+        self.intensity = intensity
+
+    def check_dispatch(self, win, stickid, buttonid):
+        if buttonid == 6:
+            self.cursor_hold = not self.cursor_hold
+        if buttonid not in (2, 3, 4, 5, 6):
+            return
+
+        x, y = self.center
+        # window event, correction necessary
+        y = self.win.system_size[1] - y
+        modifiers = []
+        actions = {
+            2: 'left',
+            3: 'right',
+            4: 'scrollup',
+            5: 'scrolldown',
+            6: 'left'
+        }
+        button = actions[buttonid]
+
+        self.win.dispatch('on_mouse_down', x, y, button, modifiers)
+        if not self.cursor_hold:
+            self.win.dispatch('on_mouse_up', x, y, button, modifiers)
+
+    def move_cursor(self, *args):
+        # move joycursor as a mouse
+        self.pos[0] += self.offset_x
+        self.pos[1] += self.offset_y
+        modifiers = []
+        if self.cursor_hold:
+            self.win.dispatch(
+                'on_mouse_move',
+                self.center[0],
+                self.win.system_size[1] - self.center[1],
+                modifiers
+            )
+
+    def stop_cursor(self, instance, mouse_pos):
+        # pin the cursor to the mouse pos
+        self.offset_x = 0
+        self.offset_y = 0
+        self.pos = (
+            mouse_pos[0] - self.size[0] / 2.0,
+            mouse_pos[1] - self.size[1] / 2.0
+        )
+
+    def on_pos(self, instance, new_pos):
+        self.set_cursor()
+        self.cursor_x.points = self.cursor_pts[:4]
+        self.cursor_y.points = self.cursor_pts[4:]
+        self.cursor_ox.points = self.cursor_pts[:4]
+        self.cursor_oy.points = self.cursor_pts[4:]
+
+    def keyboard_shortcuts(self, win, scancode, *args):
+        modifiers = args[-1]
+        if scancode == 101 and modifiers == ['ctrl']:
+            self.activated = not self.activated
+            return True
+        elif scancode == 27:
+            if self.activated:
+                self.activated = False
+                return True
+
+    def joystick_shortcuts(self, win, stickid, buttonid):
+        if buttonid == 7:
+            self.activated = not self.activated
+            if self.activated:
+                self.pos = [round(i / 2.0) for i in win.size]
+
+
+def create_joycursor(win, ctx, *args):
+    '''Create a JoyCursor instance attached to the *ctx* and bound to the
+    Window's :meth:`~kivy.core.window.WindowBase.on_keyboard` event for
+    capturing the keyboard shortcuts.
+
+        :Parameters:
+            `win`: A :class:`Window <kivy.core.window.WindowBase>`
+                The application Window to bind to.
+            `ctx`: A :class:`~kivy.uix.widget.Widget` or subclass
+                The Widget for JoyCursor to attach to.
+
+    '''
+    ctx.joycursor = JoyCursor(win=win)
+    win.bind(children=ctx.joycursor.on_window_children,
+             on_keyboard=ctx.joycursor.keyboard_shortcuts)
+    # always listen for joystick input to open the module
+    # (like a keyboard listener)
+    win.fbind('on_joy_button_down', ctx.joycursor.joystick_shortcuts)
+
+
+def start(win, ctx):
+    Clock.schedule_once(lambda *t: create_joycursor(win, ctx))
+
+
+def stop(win, ctx):
+    '''Stop and unload any active JoyCursors for the given *ctx*.
+    '''
+    if hasattr(ctx, 'joycursor'):
+        ctx.joycursor.activated = False
+        win.unbind(children=ctx.joycursor.on_window_children,
+                   on_keyboard=ctx.joycursor.keyboard_shortcuts)
+        win.funbind('on_joy_button_down', ctx.joycursor.joystick_shortcuts)
+        win.remove_widget(ctx.joycursor)
+        del ctx.joycursor
diff --git a/kivy/modules/keybinding.py b/kivy/modules/keybinding.py
new file mode 100644
index 0000000..f941c8d
--- /dev/null
+++ b/kivy/modules/keybinding.py
@@ -0,0 +1,64 @@
+'''Keybinding
+==========
+
+This module forces the mapping of some keys to functions:
+
+* F11: Rotate the Window through 0, 90, 180 and 270 degrees
+* Shift + F11: Switches between portrait and landscape on desktops
+* F12: Take a screenshot
+
+Note: this doesn't work if the application requests the keyboard beforehand.
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation.
+
+The Keybinding module, however, can also be imported and used just
+like a normal python module. This has the added advantage of being
+able to activate and deactivate the module programmatically::
+
+    from kivy.app import App
+    from kivy.uix.button import Button
+    from kivy.modules import keybinding
+    from kivy.core.window import Window
+
+    class Demo(App):
+
+        def build(self):
+            button = Button(text="Hello")
+            keybinding.start(Window, button)
+            return button
+
+    Demo().run()
+
+To remove the Keybinding, you can do the following::
+
+    Keybinding.stop(Window, button)
+
+'''
+
+from kivy.utils import platform
+
+__all__ = ('start', 'stop')
+
+
+def _on_keyboard_handler(instance, key, scancode, codepoint, modifiers):
+    if key == 293 and modifiers == []:  # F12
+        instance.screenshot()
+    elif key == 292 and modifiers == []:  # F11
+        instance.rotation += 90
+    elif key == 292 and modifiers == ['shift']:  # Shift + F11
+        if platform in ('win', 'linux', 'macosx'):
+            instance.rotation = 0
+            w, h = instance.size
+            w, h = h, w
+            instance.size = (w, h)
+
+
+def start(win, ctx):
+    win.bind(on_keyboard=_on_keyboard_handler)
+
+
+def stop(win, ctx):
+    win.unbind(on_keyboard=_on_keyboard_handler)
diff --git a/kivy/modules/monitor.py b/kivy/modules/monitor.py
new file mode 100644
index 0000000..47f3adc
--- /dev/null
+++ b/kivy/modules/monitor.py
@@ -0,0 +1,88 @@
+'''
+Monitor module
+==============
+
+The Monitor module is a toolbar that shows the activity of your current
+application :
+
+* FPS
+* Graph of input events
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation.
+
+'''
+
+__all__ = ('start', 'stop')
+
+from kivy.uix.label import Label
+from kivy.graphics import Rectangle, Color
+from kivy.clock import Clock
+from functools import partial
+
+_statsinput = 0
+_maxinput = -1
+
+
+def update_fps(ctx, *largs):
+    ctx.label.text = 'FPS: %f' % Clock.get_fps()
+    ctx.rectangle.texture = ctx.label.texture
+    ctx.rectangle.size = ctx.label.texture_size
+
+
+def update_stats(win, ctx, *largs):
+    global _statsinput
+    ctx.stats = ctx.stats[1:] + [_statsinput]
+    _statsinput = 0
+    m = max(1., _maxinput)
+    for i, x in enumerate(ctx.stats):
+        ctx.statsr[i].size = (4, ctx.stats[i] / m * 20)
+        ctx.statsr[i].pos = (win.width - 64 * 4 + i * 4, win.height - 25)
+
+
+def _update_monitor_canvas(win, ctx, *largs):
+    with win.canvas.after:
+        ctx.overlay.pos = (0, win.height - 25)
+        ctx.overlay.size = (win.width, 25)
+        ctx.rectangle.pos = (5, win.height - 20)
+
+
+class StatsInput(object):
+    def process(self, events):
+        global _statsinput, _maxinput
+        _statsinput += len(events)
+        if _statsinput > _maxinput:
+            _maxinput = float(_statsinput)
+        return events
+
+
+def start(win, ctx):
+    # late import to avoid breaking module loading
+    from kivy.input.postproc import kivy_postproc_modules
+    kivy_postproc_modules['fps'] = StatsInput()
+    global _ctx
+    ctx.label = Label(text='FPS: 0.0')
+    ctx.inputstats = 0
+    ctx.stats = []
+    ctx.statsr = []
+    with win.canvas.after:
+        ctx.color = Color(1, 0, 0, .5)
+        ctx.overlay = Rectangle(pos=(0, win.height - 25),
+                                size=(win.width, 25))
+        ctx.color = Color(1, 1, 1)
+        ctx.rectangle = Rectangle(pos=(5, win.height - 20))
+        ctx.color = Color(1, 1, 1, .5)
+        for i in range(64):
+            ctx.stats.append(0)
+            ctx.statsr.append(
+                Rectangle(pos=(win.width - 64 * 4 + i * 4, win.height - 25),
+                          size=(4, 0)))
+    win.bind(size=partial(_update_monitor_canvas, win, ctx))
+    Clock.schedule_interval(partial(update_fps, ctx), .5)
+    Clock.schedule_interval(partial(update_stats, win, ctx), 1 / 60.)
+
+
+def stop(win, ctx):
+    win.canvas.remove(ctx.label)
diff --git a/kivy/modules/recorder.py b/kivy/modules/recorder.py
new file mode 100644
index 0000000..f16cbed
--- /dev/null
+++ b/kivy/modules/recorder.py
@@ -0,0 +1,94 @@
+'''
+Recorder module
+===============
+
+.. versionadded:: 1.1.0
+
+Create an instance of :class:`~kivy.input.recorder.Recorder`, attach to the
+class, and bind some keys to record / play sequences:
+
+    - F6: play the last record in a loop
+    - F7: read the latest recording
+    - F8: record input events
+
+Configuration
+-------------
+
+.. |attrs| replace:: :attr:`~kivy.input.recorder.Recorder.record_attrs`
+.. |profile_mask| replace::
+    :attr:`~kivy.input.recorder.Recorder.record_profile_mask`
+
+:Parameters:
+    `attrs`: str, defaults to |attrs| value.
+        Attributes to record from the motion event
+    `profile_mask`: str, defaults to |profile_mask| value.
+        Mask for motion event profile. Used to filter which profile will appear
+        in the fake motion event when replayed.
+    `filename`: str, defaults to 'recorder.kvi'
+        Name of the file to record / play with
+
+Usage
+-----
+
+For normal module usage, please see the :mod:`~kivy.modules` documentation.
+
+'''
+
+__all__ = ('start', 'stop')
+
+from kivy.logger import Logger
+from functools import partial
+
+
+def replay(recorder, *args):
+    if recorder.play:
+        return
+    else:
+        recorder.play = True
+
+
+def on_recorder_key(recorder, window, key, *largs):
+    if key == 289:  # F8
+        if recorder.play:
+            Logger.error('Recorder: Cannot start recording while playing.')
+            return
+        recorder.record = not recorder.record
+    elif key == 288:  # F7
+        if recorder.record:
+            Logger.error('Recorder: Cannot start playing while recording.')
+            return
+        recorder.play = not recorder.play
+    elif key == 287:  # F6
+        if recorder.play:
+            recorder.unbind(play=replay)
+        else:
+            recorder.bind(play=replay)
+            recorder.play = True
+
+
+def start(win, ctx):
+    keys = {}
+
+    # attributes
+    value = ctx.config.get('attrs', None)
+    if value is not None:
+        keys['record_attrs'] = value.split(':')
+
+    # profile mask
+    value = ctx.config.get('profile_mask', None)
+    if value is not None:
+        keys['record_profile_mask'] = value.split(':')
+
+    # filename
+    value = ctx.config.get('filename', None)
+    if value is not None:
+        keys['filename'] = value
+
+    from kivy.input.recorder import Recorder
+    ctx.recorder = Recorder(window=win, **keys)
+    win.bind(on_key_down=partial(on_recorder_key, ctx.recorder))
+
+
+def stop(win, ctx):
+    if hasattr(ctx, 'recorder'):
+        ctx.recorder.release()
diff --git a/kivy/modules/screen.py b/kivy/modules/screen.py
new file mode 100644
index 0000000..2242e99
--- /dev/null
+++ b/kivy/modules/screen.py
@@ -0,0 +1,183 @@
+'''Screen
+======
+
+This module changes some environment and configuration variables
+to match the density / dpi / screensize of a specific device.
+
+To see a list of the available screenid's, just run::
+
+    python main.py -m screen
+
+To simulate a medium-density screen such as the Motorola Droid 2::
+
+    python main.py -m screen:droid2
+
+To simulate a high-density screen such as HTC One X, in portrait::
+
+    python main.py -m screen:onex,portrait
+
+To simulate the iPad 2 screen::
+
+    python main.py -m screen:ipad
+
+If the generated window is too large, you can specify a scale::
+
+    python main.py -m screen:note2,portrait,scale=.75
+
+Note that to display your contents correctly on a scaled window you
+must consistently use units 'dp' and 'sp' throughout your app. See
+:mod:`~kiv.metrics` for more details.
+
+'''
+
+import sys
+from os import environ
+from kivy.config import Config
+from kivy.logger import Logger
+
+# taken from http://en.wikipedia.org/wiki/List_of_displays_by_pixel_density
+devices = {
+    # device: (name, width, height, dpi, density)
+    'onex': ('HTC One X', 1280, 720, 312, 2),
+    'one': ('HTC One', 1920, 1080, 468, 3),
+    'onesv': ('HTC One SV', 800, 480, 216, 1.5),
+    's3': ('Galaxy SIII', 1280, 720, 306, 2),
+    'note2': ('Galaxy Note II', 1280, 720, 267, 2),
+    'droid2': ('Motorola Droid 2', 854, 480, 240, 1.5),
+    'xoom': ('Motorola Xoom', 1280, 800, 149, 1),
+    'ipad': ('iPad (1 and 2)', 1024, 768, 132, 1),
+    'ipad3': ('iPad 3', 2048, 1536, 264, 2),
+    'iphone4': ('iPhone 4', 960, 640, 326, 2),
+    'iphone5': ('iPhone 5', 1136, 640, 326, 2),
+    'xperiae': ('Xperia E', 480, 320, 166, 1),
+    'nexus4': ('Nexus 4', 1280, 768, 320, 2),
+    'nexus7': ('Nexus 7 (2012 version)', 1280, 800, 216, 1.325),
+    'nexus7.2': ('Nexus 7 (2013 version)', 1920, 1200, 323, 2),
+
+    # taken from design.google.com/devices
+    # please consider using another data instead of
+    # a dict for autocompletion to work
+    # these are all in landscape
+    'phone_android_one': ('Android One', 854, 480, 218, 1.5),
+    'phone_htc_one_m8': ('HTC One M8', 1920, 1080, 432, 3.0),
+    'phone_htc_one_m9': ('HTC One M9', 1920, 1080, 432, 3.0),
+    'phone_iphone': ('iPhone', 480, 320, 168, 1.0),
+    'phone_iphone_4': ('iPhone 4', 960, 640, 320, 2.0),
+    'phone_iphone_5': ('iPhone 5', 1136, 640, 320, 2.0),
+    'phone_iphone_6': ('iPhone 6', 1334, 750, 326, 2.0),
+    'phone_iphone_6_plus': ('iPhone 6 Plus', 1920, 1080, 400, 3.0),
+    'phone_lg_g2': ('LG G2', 1920, 1080, 432, 3.0),
+    'phone_lg_g3': ('LG G3', 2560, 1440, 533, 3.0),
+    'phone_moto_g': ('Moto G', 1280, 720, 327, 2.0),
+    'phone_moto_x': ('Moto X', 1280, 720, 313, 2.0),
+    'phone_moto_x_2nd_gen': ('Moto X 2nd Gen', 1920, 1080, 432, 3.0),
+    'phone_nexus_4': ('Nexus 4', 1280, 768, 240, 2.0),
+    'phone_nexus_5': ('Nexus 5', 1920, 1080, 450, 3.0),
+    'phone_nexus_5x': ('Nexus 5X', 1920, 1080, 432, 2.6),
+    'phone_nexus_6': ('Nexus 6', 2560, 1440, 496, 3.5),
+    'phone_nexus_6p': ('Nexus 6P', 2560, 1440, 514, 3.5),
+    'phone_oneplus_3t': ('OnePlus 3t', 1863, 1080, 380, 2.375),
+    'phone_oneplus_6t': ('OnePlus 6t', 2340, 1080, 420, 2.625),
+    'phone_samsung_galaxy_note_4': ('Samsung Galaxy Note 4',
+                                    2560, 1440, 514, 3.0),
+    'phone_samsung_galaxy_s5': ('Samsung Galaxy S5', 1920, 1080, 372, 3.0),
+    'phone_samsung_galaxy_s6': ('Samsung Galaxy S6', 2560, 1440, 576, 4.0),
+    'phone_sony_xperia_c4': ('Sony Xperia C4', 1920, 1080, 400, 2.0),
+    'phone_sony_xperia_z_ultra': ('Sony Xperia Z Ultra', 1920, 1080, 348, 2.0),
+    'phone_sony_xperia_z1_compact': ('Sony Xperia Z1 Compact',
+                                     1280, 720, 342, 2.0),
+    'phone_sony_xperia_z2z3': ('Sony Xperia Z2/Z3', 1920, 1080, 432, 3.0),
+    'phone_sony_xperia_z3_compact': ('Sony Xperia Z3 Compact',
+                                     1280, 720, 313, 2.0),
+    'tablet_dell_venue_8': ('Dell Venue 8', 2560, 1600, 355, 2.0),
+    'tablet_ipad': ('iPad', 1024, 768, 132, 1.0),
+    'tablet_ipad_mini': ('iPad Mini', 1024, 768, 163, 1.0),
+    'tablet_ipad_mini_retina': ('iPad Mini Retina', 2048, 1536, 326, 2.0),
+    'tablet_ipad_pro': ('iPad Pro', 2732, 2048, 265, 2.0),
+    'tablet_ipad_retina': ('iPad Retina', 2048, 1536, 264, 2.0),
+    'tablet_nexus_10': ('Nexus 10', 2560, 1600, 297, 2.0),
+    'tablet_nexus_7_12': ('Nexus 7 12', 1280, 800, 216, 1.3),
+    'tablet_nexus_7_13': ('Nexus 7 13', 1920, 1200, 324, 2.0),
+    'tablet_nexus_9': ('Nexus 9', 2048, 1536, 288, 2.0),
+    'tablet_samsung_galaxy_tab_10': ('Samsung Galaxy Tab 10',
+                                     1280, 800, 148, 1.0),
+    'tablet_sony_xperia_z3_tablet': ('Sony Xperia Z3 Tablet',
+                                     1920, 1200, 282, 2.0),
+    'tablet_sony_xperia_z4_tablet': ('Sony Xperia Z4 Tablet',
+                                     2560, 1600, 297, 2.0),
+    'tablet_huawei_mediapad_m3_lite_10': ('HUAWEI MediaPad M3 Lite 10',
+                                          1920, 1200, 320, 2.25)
+
+}
+
+
+def start(win, ctx):
+    pass
+
+
+def stop(win, ctx):
+    pass
+
+
+def apply_device(device, scale, orientation):
+    name, width, height, dpi, density = devices[device]
+    if orientation == 'portrait':
+        width, height = height, width
+    Logger.info('Screen: Apply screen settings for {0}'.format(name))
+    Logger.info('Screen: size={0}x{1} dpi={2} density={3} '
+                'orientation={4}'.format(width, height, dpi, density,
+                                         orientation))
+    try:
+        scale = float(scale)
+    except:
+        scale = 1
+    environ['KIVY_METRICS_DENSITY'] = str(density * scale)
+    environ['KIVY_DPI'] = str(dpi * scale)
+    Config.set('graphics', 'width', str(int(width * scale)))
+    # simulate with the android bar
+    # FIXME should be configurable
+    Config.set('graphics', 'height', str(int(height * scale - 25 * density)))
+    Config.set('graphics', 'fullscreen', '0')
+    Config.set('graphics', 'show_mousecursor', '1')
+
+
+def usage(device=None):
+    if device:
+        Logger.error('Screen: The specified device ({0}) is unknown.',
+                     device)
+    print('\nModule usage: python main.py -m screen:deviceid[,orientation]\n')
+    print('Available devices:\n')
+    print('{0:12} {1:<22} {2:<8} {3:<8} {4:<5} {5:<8}'.format(
+        'Device ID', 'Name', 'Width', 'Height', 'DPI', 'Density'))
+    for device, info in devices.items():
+        print('{0:12} {1:<22} {2:<8} {3:<8} {4:<5} {5:<8}'.format(
+            device, *info))
+    print('\n')
+    print('Simulate a medium-density screen such as Motorola Droid 2:\n')
+    print('    python main.py -m screen:droid2\n')
+    print('Simulate a high-density screen such as HTC One X, in portrait:\n')
+    print('    python main.py -m screen:onex,portrait\n')
+    print('Simulate the iPad 2 screen\n')
+    print('    python main.py -m screen:ipad\n')
+    print('If the generated window is too large, you can specify a scale:\n')
+    print('    python main.py -m screen:note2,portrait,scale=.75\n')
+    sys.exit(1)
+
+
+def configure(ctx):
+    scale = ctx.pop('scale', None)
+    orientation = 'landscape'
+    ctx.pop('landscape', None)
+    if ctx.pop('portrait', None):
+        orientation = 'portrait'
+    if not ctx:
+        return usage(None)
+    device = list(ctx.keys())[0]
+    if device not in devices:
+        return usage('')
+    apply_device(device, scale, orientation)
+
+
+if __name__ == "__main__":
+    for n in devices.values():
+        assert n[1] > n[2]
diff --git a/kivy/modules/showborder.py b/kivy/modules/showborder.py
new file mode 100644
index 0000000..890266c
--- /dev/null
+++ b/kivy/modules/showborder.py
@@ -0,0 +1,33 @@
+'''
+Show border
+===========
+
+Shows widget's border.
+
+The idea was taken from
+http://robertour.com/2013/10/02/easy-way-debugging-kivy-interfaces/
+'''
+
+__all__ = ('start', 'stop')
+
+from kivy.lang import Builder
+
+
+KV_CODE = '''
+<Widget>:
+    canvas.after:
+        Color:
+            rgba: 1, 1, 1, 1
+        Line:
+            rectangle: self.x + 1, self.y + 1, self.width - 1, self.height - 1
+            dash_offset: 5
+            dash_length: 3
+'''
+
+
+def start(win, ctx):
+    Builder.load_string(KV_CODE, filename=__file__)
+
+
+def stop(win, ctx):
+    Builder.unload_file(__file__)
diff --git a/kivy/modules/touchring.py b/kivy/modules/touchring.py
new file mode 100644
index 0000000..0a8c937
--- /dev/null
+++ b/kivy/modules/touchring.py
@@ -0,0 +1,97 @@
+'''
+Touchring
+=========
+
+Shows rings around every touch on the surface / screen. You can use this module
+to check that you don't have any calibration issues with touches.
+
+Configuration
+-------------
+
+:Parameters:
+    `image`: str, defaults to '<kivy>/data/images/ring.png'
+        Filename of the image to use.
+    `scale`: float, defaults to 1.
+        Scale of the image.
+    `alpha`: float, defaults to 1.
+        Opacity of the image.
+
+Example
+-------
+
+In your configuration (`~/.kivy/config.ini`), you can add something like
+this::
+
+    [modules]
+    touchring = image=mypointer.png,scale=.3,alpha=.7
+
+'''
+
+__all__ = ('start', 'stop')
+
+from kivy.core.image import Image
+from kivy.graphics import Color, Rectangle
+from kivy import kivy_data_dir
+from os.path import join
+
+pointer_image = None
+pointer_scale = 1.0
+pointer_alpha = 0.7
+
+
+def _touch_down(win, touch):
+    ud = touch.ud
+    with win.canvas.after:
+        ud['tr.color'] = Color(1, 1, 1, pointer_alpha)
+        iw, ih = pointer_image.size
+        ud['tr.rect'] = Rectangle(
+            pos=(
+                touch.x - (pointer_image.width / 2. * pointer_scale),
+                touch.y - (pointer_image.height / 2. * pointer_scale)),
+            size=(iw * pointer_scale, ih * pointer_scale),
+            texture=pointer_image.texture)
+
+    if not ud.get('tr.grab', False):
+        ud['tr.grab'] = True
+        touch.grab(win)
+
+
+def _touch_move(win, touch):
+    ud = touch.ud
+    if not ud.get('tr.rect', False):
+        _touch_down(win, touch)
+    ud['tr.rect'].pos = (
+        touch.x - (pointer_image.width / 2. * pointer_scale),
+        touch.y - (pointer_image.height / 2. * pointer_scale))
+
+
+def _touch_up(win, touch):
+    if touch.grab_current is win:
+        ud = touch.ud
+        win.canvas.after.remove(ud['tr.color'])
+        win.canvas.after.remove(ud['tr.rect'])
+
+        if ud.get('tr.grab') is True:
+            touch.ungrab(win)
+            ud['tr.grab'] = False
+
+
+def start(win, ctx):
+    # XXX use ctx !
+    global pointer_image, pointer_scale, pointer_alpha
+
+    pointer_fn = ctx.config.get('image',
+                                'atlas://data/images/defaulttheme/ring')
+    pointer_scale = float(ctx.config.get('scale', 1.0))
+    pointer_alpha = float(ctx.config.get('alpha', 1.0))
+    pointer_image = Image(pointer_fn)
+
+    win.bind(on_touch_down=_touch_down,
+             on_touch_move=_touch_move,
+             on_touch_up=_touch_up)
+
+
+def stop(win, ctx):
+    win.unbind(on_touch_down=_touch_down,
+               on_touch_move=_touch_move,
+               on_touch_up=_touch_up)
diff --git a/kivy/modules/webdebugger.py b/kivy/modules/webdebugger.py
new file mode 100644
index 0000000..ff55046
--- /dev/null
+++ b/kivy/modules/webdebugger.py
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+'''
+Web Debugger
+============
+
+.. versionadded:: 1.2.0
+
+.. warning::
+
+    This module is highly experimental, use it with care.
+
+This module will start a webserver and run in the background. You can
+see how your application evolves during runtime, examine the internal
+cache etc.
+
+Run with::
+
+    python main.py -m webdebugger
+
+Then open your webbrowser on http://localhost:5000/
+
+'''
+
+__all__ = ('start', 'stop')
+
+import os
+if 'KIVY_DOC' not in os.environ:
+    from kivy.modules._webdebugger import start, stop
+else:
+    start = stop = lambda *x: True
diff --git a/kivy/multistroke.py b/kivy/multistroke.py
new file mode 100644
index 0000000..f124351
--- /dev/null
+++ b/kivy/multistroke.py
@@ -0,0 +1,1477 @@
+'''
+Multistroke gesture recognizer
+==============================
+
+.. versionadded::
+    1.9.0
+
+.. warning::
+
+    This is experimental and subject to change as long as this warning notice
+    is present.
+
+See :file:`kivy/examples/demo/multistroke/main.py` for a complete application
+example.
+
+Conceptual Overview
+-------------------
+
+This module implements the Protractor gesture recognition algorithm.
+
+:class:`Recognizer` is the search/database API similar to
+:class:`~kivy.gesture.GestureDatabase`. It maintains a list of
+:class:`MultistrokeGesture` objects and allows you to search for a
+user-input gestures among them.
+
+:class:`ProgressTracker` tracks the progress of a :meth:`Recognizer.recognize`
+call. It can be used to interact with the running recognizer task, for example
+forcing it to stop half-way, or analyzing results as they arrive.
+
+:class:`MultistrokeGesture` represents a gesture in the gesture database
+(:attr:`Recognizer.db`). It is a container for :class:`UnistrokeTemplate`
+objects, and implements the heap permute algorithm to automatically generate
+all possible stroke orders (if desired).
+
+:class:`UnistrokeTemplate` represents a single stroke path. It's typically
+instantiated automatically by :class:`MultistrokeGesture`, but sometimes you
+may need to create them manually.
+
+:class:`Candidate` represents a user-input gesture that is used to search
+the gesture database for matches. It is normally instantiated automatically
+by calling :meth:`Recognizer.recognize`.
+
+Usage examples
+--------------
+
+See :file:`kivy/examples/demo/multistroke/main.py` for a complete application
+example.
+
+You can bind to events on :class:`Recognizer` to track the state of all
+calls to :meth:`Recognizer.recognize`. The callback function will receive an
+instance of :class:`ProgressTracker` that can be used to analyze and control
+various aspects of the recognition process ::
+
+    from kivy.vector import Vector
+    from kivy.multistroke import Recognizer
+
+    gdb = Recognizer()
+
+    def search_start(gdb, pt):
+        print("A search is starting with %d tasks" % (pt.tasks))
+
+    def search_stop(gdb, pt):
+        # This will call max() on the result dictionary, so it's best to store
+        # it instead of calling it 3 times consecutively
+        best = pt.best
+        print("Search ended (%s). Best is %s (score %f, distance %f)" % (
+            pt.status, best['name'], best['score'], best['dist'] ))
+
+    # Bind your callbacks to track all matching operations
+    gdb.bind(on_search_start=search_start)
+    gdb.bind(on_search_complete=search_stop)
+
+    # The format below is referred to as `strokes`, a list of stroke paths.
+    # Note that each path shown here consists of two points, ie a straight
+    # line; if you plot them it looks like a T, hence the name.
+    gdb.add_gesture('T', [
+        [Vector(30, 7), Vector(103, 7)],
+        [Vector(66, 7), Vector(66, 87)]])
+
+    # Now you can search for the 'T' gesture using similar data (user input).
+    # This will trigger both of the callbacks bound above.
+    gdb.recognize([
+        [Vector(45, 8), Vector(110, 12)],
+        [Vector(88, 9), Vector(85, 95)]])
+
+On the next :class:`~kivy.clock.Clock` tick, the matching process starts
+(and, in this case, completes).
+
+To track individual calls to :meth:`Recognizer.recognize`, use the return
+value (also a :class:`ProgressTracker` instance) ::
+
+    # Same as above, but keep track of progress using returned value
+    progress = gdb.recognize([
+        [Vector(45, 8), Vector(110, 12)],
+        [Vector(88, 9), Vector(85, 95)]])
+
+    progress.bind(on_progress=my_other_callback)
+    print(progress.progress) # = 0
+
+    # [ assuming a kivy.clock.Clock.tick() here ]
+
+    print(result.progress) # = 1
+
+Algorithm details
+-----------------
+
+For more information about the matching algorithm, see:
+
+"Protractor: A fast and accurate gesture recognizer" by Yang Li
+  http://yangl.org/pdf/protractor-chi2010.pdf
+
+"$N-Protractor" by Lisa Anthony and Jacob O. Wobbrock
+  http://depts.washington.edu/aimgroup/proj/dollar/ndollar-protractor.pdf
+
+Some of the code is derived from the JavaScript implementation here:
+  http://depts.washington.edu/aimgroup/proj/dollar/ndollar.html
+'''
+
+__all__ = ('Recognizer', 'ProgressTracker', 'MultistrokeGesture',
+           'UnistrokeTemplate', 'Candidate')
+
+import pickle
+import base64
+import zlib
+from re import match as re_match
+from collections import deque
+from math import sqrt, pi, radians, acos, atan, atan2, pow, floor
+from math import sin as math_sin, cos as math_cos
+from kivy.vector import Vector
+from kivy.clock import Clock
+from kivy.event import EventDispatcher
+from kivy.properties import ListProperty
+from kivy.compat import PY2
+from io import BytesIO
+
+if not PY2:
+    xrange = range
+
+# Default number of gesture matches per frame
+# FIXME: relevant number
+DEFAULT_GPF = 10
+
+# Algorithm data
+SQUARESIZE = 250.0
+ONEDTHRESHOLD = 0.25
+ORIGIN = Vector(0, 0)
+
+
+class MultistrokeError(Exception):
+    pass
+
+
+# -----------------------------------------------------------------------------
+# Recognizer
+# -----------------------------------------------------------------------------
+
+class Recognizer(EventDispatcher):
+    ''':class:`Recognizer` provides a gesture database with matching
+    facilities.
+
+    :Events:
+        `on_search_start`
+            Fired when a new search is started using this Recognizer.
+
+        `on_search_complete`
+            Fired when a running search ends, for whatever reason.
+            (use :data:`ProgressTracker.status` to find out)
+
+    :Properties:
+        `db`
+            A :class:`ListProperty` that contains the available
+            :class:`MultistrokeGesture` objects.
+
+            :attr:`db` is a
+            :class:`~kivy.properties.ListProperty` and defaults to []
+    '''
+
+    db = ListProperty([])
+
+    def __init__(self, **kwargs):
+        super(Recognizer, self).__init__(**kwargs)
+        self.register_event_type('on_search_start')
+        self.register_event_type('on_search_complete')
+
+    def filter(self, **kwargs):
+        ''':meth:`filter` returns a subset of objects in :attr:`self.db`,
+        according to given criteria. This is used by many other methods of
+        the :class:`Recognizer`; the arguments below can for example be
+        used when calling :meth:`Recognizer.recognize` or
+        :meth:`Recognizer.export_gesture`. You normally don't need to call
+        this directly.
+
+        :Arguments:
+
+            `name`
+                Limits the returned list to gestures where
+                :attr:`MultistrokeGesture.name` matches given regular
+                expression(s). If re.match(name, MultistrokeGesture.name)
+                tests true, the gesture is included in the returned list.
+                Can be a string or an array of strings ::
+
+                    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'])
+
+            `priority`
+                Limits the returned list to gestures with certain
+                :attr:`MultistrokeGesture.priority` values. If specified as an
+                integer, only gestures with a lower priority are returned. If
+                specified as a list (min/max) ::
+
+                    # Max priority 50
+                    gdb.filter(priority=50)
+
+                    # Max priority 50 (same result as above)
+                    gdb.filter(priority=[0, 50])
+
+                    # Min priority 50, max 100
+                    gdb.filter(priority=[50, 100])
+
+                When this option is used, :attr:`Recognizer.db` is
+                automatically sorted according to priority, incurring extra
+                cost. You can use `force_priority_sort` to override this
+                behavior if your gestures are already sorted according to
+                priority.
+
+            `orientation_sensitive`
+                Limits the returned list to gestures that are
+                orientation sensitive (True), gestures that are not orientation
+                sensitive (False) or None (ignore template sensitivity, this is
+                the default).
+
+            `numstrokes`
+                Limits the returned list to gestures that have the specified
+                number of strokes (in :attr:`MultistrokeGesture.strokes`).
+                Can be a single integer or a list of integers.
+
+            `numpoints`
+                Limits the returned list to gestures that have specific
+                :attr:`MultistrokeGesture.numpoints` values. This is provided
+                for flexibility, do not use it unless you understand what it
+                does. Can be a single integer or a list of integers.
+
+            `force_priority_sort`
+                Can be used to override the default sort behavior. Normally
+                :class:`MultistrokeGesture` objects are returned in priority
+                order if the `priority` option is used. Setting this to True
+                will return gestures sorted in priority order, False will
+                return in the order gestures were added. None means decide
+                automatically (the default).
+
+                .. Note ::
+                    For improved performance, you can load your gesture
+                    database in priority order and set this to False when
+                    calling :meth:`Recognizer.recognize`
+
+            `db`
+                Can be set if you want to filter a different list of objects
+                than :attr:`Recognizer.db`. You probably don't want to do this;
+                it is used internally by :meth:`import_gesture`.
+        '''
+        have_filters = False
+
+        kwargs_get = kwargs.get
+
+        name = kwargs_get('name', None)
+        if name is not None:
+            have_filters = True
+            if not isinstance(name, list):
+                name = [name]
+
+        priority = kwargs_get('priority', None)
+        min_p, max_p = None, None
+        if priority is not None:
+            have_filters = True
+            if isinstance(priority, list):
+                min_p, max_p = priority
+            elif isinstance(priority, int):
+                min_p, max_p = None, priority
+
+        numstrokes = kwargs_get('numstrokes', None)
+        if numstrokes is not None:
+            have_filters = True
+            if not isinstance(numstrokes, list):
+                numstrokes = [numstrokes]
+
+        numpoints = kwargs_get('numpoints', None)
+        if numpoints is not None:
+            have_filters = True
+            if not isinstance(numpoints, list):
+                numpoints = [numpoints]
+
+        orientation_sens = kwargs_get('orientation_sensitive', None)
+        if orientation_sens is not None:
+            have_filters = True
+
+        # Prepare a correctly sorted tasklist
+        force_priority_sort = kwargs.get('force_priority_sort', None)
+        force_sort_on = force_priority_sort and True
+        force_sort_off = (force_priority_sort is False) and True
+
+        db = kwargs.get('db', None) or self.db
+        if (force_sort_on or priority) and not force_sort_off:
+            tasklist = sorted(db, key=lambda n: n.priority)
+        else:
+            tasklist = db
+
+        # Now test each gesture in the database against filter criteria
+        out = deque()
+        if not have_filters:
+            out.extend(tasklist)
+            return out
+
+        out_append = out.append
+        for gesture in tasklist:
+
+            if (orientation_sens is not None and
+                    orientation_sens != gesture.orientation_sens):
+                continue
+
+            if numpoints and gesture.numpoints not in numpoints:
+                continue
+
+            if numstrokes and len(gesture.strokes) not in numstrokes:
+                continue
+
+            if min_p is not None and gesture.priority < min_p:
+                continue
+
+            if max_p is not None and gesture.priority > max_p:
+                return out
+
+            if name:
+                for f in name:
+                    if re_match(f, gesture.name):
+                        out_append(gesture)
+                        break
+            else:
+                out_append(gesture)
+
+        return out
+
+    def add_gesture(self, name, strokes, **kwargs):
+        '''Add a new gesture to the database. This will instantiate a new
+        :class:`MultistrokeGesture` with `strokes` and append it to self.db.
+
+        .. Note ::
+            If you already have instantiated a :class:`MultistrokeGesture`
+            object and wish to add it, append it to :attr:`Recognizer.db`
+            manually.
+        '''
+        if not strokes:
+            return False
+        self.db.append(
+            MultistrokeGesture(name=name, strokes=strokes, **kwargs)
+        )
+        return True
+
+    def parse_gesture(self, data):
+        '''Parse data formatted by export_gesture(). Returns a list of
+        :class:`MultistrokeGesture` objects. This is used internally by
+        :meth:`import_gesture`, you normally don't need to call this
+        directly.'''
+        io = BytesIO(zlib.decompress(base64.b64decode(data)))
+
+        p = pickle.Unpickler(io)
+        multistrokes = []
+        ms_append = multistrokes.append
+        for multistroke in p.load():
+            strokes = multistroke['strokes']
+            multistroke['strokes'] = [[Vector(
+                x, y) for x, y in line] for line in strokes]
+            ms_append(MultistrokeGesture(**multistroke))
+        return multistrokes
+
+    # FIXME: use a try block, maybe shelve or something
+    def export_gesture(self, filename=None, **kwargs):
+        '''Export a list of :class:`MultistrokeGesture` objects. Outputs a
+        base64-encoded string that can be decoded to a Python list with
+        the :meth:`parse_gesture` function or imported directly to
+        :attr:`self.db` using :meth:`Recognizer.import_gesture`. If
+        `filename` is specified, the output is written to disk, otherwise
+        returned.
+
+        This method accepts optional :meth:`Recognizer.filter` arguments.
+        '''
+        io = BytesIO()
+        p = pickle.Pickler(io, protocol=0)
+        multistrokes = []
+        defaults = {'priority': 100, 'numpoints': 16, 'stroke_sens': True,
+                    'orientation_sens': False, 'angle_similarity': 30.0}
+        dkeys = defaults.keys()
+
+        for multistroke in self.filter(**kwargs):
+            m = dict(defaults)
+            m = {'name': multistroke.name}
+            for attr in dkeys:
+                m[attr] = getattr(multistroke, attr)
+            m['strokes'] = tuple([(p.x, p.y) for p in line]
+                                 for line in multistroke.strokes)
+            multistrokes.append(m)
+        p.dump(multistrokes)
+
+        if filename:
+            f = open(filename, 'wb')
+            f.write(base64.b64encode(zlib.compress(io.getvalue(), 9)))
+            f.close()
+        else:
+            return base64.b64encode(zlib.compress(io.getvalue(), 9))
+
+    # FIXME: match them all with protractor, and don't load exacts? or
+    # just compare the data or something; seems better to do this on import
+    # than on every subsequent call to recognize(). And fix it in general,
+    # too.
+    def import_gesture(self, data=None, filename=None, **kwargs):
+        '''Import a list of gestures as formatted by :meth:`export_gesture`.
+        One of `data` or `filename` must be specified.
+
+        This method accepts optional :meth:`Recognizer.filter` arguments,
+        if none are specified then all gestures in specified data are
+        imported.'''
+        if filename is not None:
+            with open(filename, "rb") as infile:
+                data = infile.read()
+        elif data is None:
+            raise MultistrokeError('import_gesture needs data= or filename=')
+
+        new = self.filter(db=self.parse_gesture(data), **kwargs)
+        if new:
+            self.db.extend(new)
+
+    def transfer_gesture(self, tgt, **kwargs):
+        '''Transfers :class:`MultistrokeGesture` objects from
+        :attr:`Recognizer.db` to another :class:`Recognizer` instance `tgt`.
+
+        This method accepts optional :meth:`Recognizer.filter` arguments.
+        '''
+        if hasattr(tgt, 'db') and isinstance(tgt.db, list):
+            send = self.filter(**kwargs)
+            if send:
+                tgt.db.append(None)
+                tgt.db[-1:] = send
+                return True
+
+    def prepare_templates(self, **kwargs):
+        '''This method is used to prepare :class:`UnistrokeTemplate` objects
+        within the gestures in self.db. This is useful if you want to minimize
+        punishment of lazy resampling by preparing all vectors in advance. If
+        you do this before a call to :meth:`Recognizer.export_gesture`, you
+        will have the vectors computed when you load the data later.
+
+        This method accepts optional :meth:`Recognizer.filter` arguments.
+
+        `force_numpoints`, if specified, will prepare all templates to the
+        given number of points (instead of each template's preferred n; ie
+        :data:`UnistrokeTemplate.numpoints`). You normally don't want to
+        do this.'''
+        for gesture in self.filter(**kwargs):
+            for tpl in gesture:
+                n = kwargs.get('force_numpoints', tpl.numpoints)
+                tpl.prepare(n)
+
+    def recognize(self, strokes, goodscore=None, timeout=0, delay=0, **kwargs):
+        '''Search for gestures matching `strokes`. Returns a
+        :class:`ProgressTracker` instance.
+
+        This method accepts optional :meth:`Recognizer.filter` arguments.
+
+        :Arguments:
+
+            `strokes`
+                A list of stroke paths (list of lists of
+                :class:`~kivy.vector.Vector` objects) that will be matched
+                against gestures in the database. Can also be a
+                :class:`Candidate` instance.
+
+                .. Warning ::
+
+                    If you manually supply a :class:`Candidate` that has a
+                    skip-flag, make sure that the correct filter arguments
+                    are set. Otherwise the system will attempt to load vectors
+                    that have not been computed. For example, if you set
+                    `skip_bounded` and do not set `orientation_sensitive` to
+                    False, it will raise an exception if an
+                    orientation_sensitive :class:`UnistrokeTemplate`
+                    is encountered.
+
+            `goodscore`
+                If this is set (between 0.0 - 1.0) and a gesture score is
+                equal to or higher than the specified value, the search is
+                immediately halted and the on_search_complete event is
+                fired (+ the on_complete event of the associated
+                :class:`ProgressTracker` instance). Default is None (disabled).
+
+            `timeout`
+                Specifies a timeout (in seconds) for when the search is
+                aborted and the results returned. This option applies only
+                when `max_gpf` is not 0. Default value is 0, meaning all
+                gestures in the database will be tested, no matter how long
+                it takes.
+
+            `max_gpf`
+                Specifies the maximum number of :class:`MultistrokeGesture`
+                objects that can be processed per frame. When exceeded, will
+                cause the search to halt and resume work in the next frame.
+                Setting to 0 will complete the search immediately (and block
+                the UI).
+
+                .. Warning ::
+
+                    This does not limit the number of
+                    :class:`UnistrokeTemplate` objects matched! If a single
+                    gesture has a million templates, they will all be
+                    processed in a single frame with max_gpf=1!
+
+            `delay`
+                Sets an optional delay between each run of the recognizer
+                loop. Normally, a run is scheduled for the next frame until
+                the tasklist is exhausted. If you set this, there will be an
+                additional delay between each run (specified in seconds).
+                Default is 0, resume in the next frame.
+
+            `force_numpoints`
+                forces all templates (and candidate) to be prepared to a
+                certain number of points. This can be useful for example if
+                you are evaluating templates for optimal n (do not use this
+                unless you understand what it does).
+        '''
+        GPF = kwargs.get('max_gpf', DEFAULT_GPF)
+
+        # Obtain a list of MultistrokeGesture objects matching filter arguments
+        tasklist = self.filter(**kwargs)
+
+        # Initialize the candidate and result objects
+        cand = self._candidate(strokes)
+        result = ProgressTracker(cand, len(tasklist))
+
+        # This is done to inform caller if they bind to on_complete and there
+        # is nothing to do; perhaps should just return None?
+        if not tasklist:
+            result.status = 'complete'
+            self.dispatch('on_search_complete', result)
+
+            def result_hack(dt):
+                result.dispatch('on_complete')
+            Clock.schedule_once(result_hack)
+            return result
+
+        # This callback is scheduled once per frame until completed
+        def _recognize_tick(dt):
+            start_gc = result._completed
+            stop_now = False
+
+            while not stop_now and (tasklist and not result._break_flag) and \
+                    (not GPF or (result._completed - start_gc < GPF)):
+
+                if (timeout and
+                        Clock.get_time() - result._start_time >= timeout):
+                    result.status = 'timeout'
+                    stop_now = True
+                    break
+
+                # Get the best distance and number of matching operations done
+                gesture = tasklist.popleft()
+                tpl, d, res, mos = gesture.match_candidate(
+                    cand, **kwargs)
+
+                if tpl is not None:
+                    score = result._add_result(gesture, d, tpl, res)
+                    if goodscore is not None and score >= goodscore:
+                        result.status = 'goodscore'
+                        stop_now = True
+
+                result._match_ops += mos
+                result._completed += 1
+                result.dispatch('on_progress')
+
+            # The loop has ended. Prepare to dispatch 'complete'
+            def _dispatch():
+                result.dispatch('on_complete')
+                self.dispatch('on_search_complete', result)
+                return False
+
+            # Dispatch or reschedule another run
+            if not tasklist:
+                result.status = 'complete'
+                return _dispatch()
+            elif result._break_flag:
+                result.status = 'stop'
+                return _dispatch()
+            elif stop_now:
+                return _dispatch()
+            else:
+                Clock.schedule_once(_recognize_tick, delay)
+                return True
+        # End _recognize_tick()
+
+        self.dispatch('on_search_start', result)
+        if not GPF:
+            _recognize_tick(0)
+        else:
+            Clock.schedule_once(_recognize_tick, 0)
+
+        return result
+
+    def _candidate(self, strokes, **kwargs):
+        # recognize() helper function, do not use directly. Set up a
+        # Candidate object from arguments. Either use a specified object
+        # or make a new one from strokes and apply safe skip_* settings to
+        # use less resources.
+        if isinstance(strokes, Candidate):
+            return strokes
+
+        if (not isinstance(strokes, list) or not len(strokes) or not
+                isinstance(strokes[0], list)):
+            raise MultistrokeError('recognize() needs strokes= '
+                                   'list or Candidate')
+
+        cand = Candidate(strokes)
+        o_filter = kwargs.get('orientation_sensitive', None)
+        if o_filter is False:
+            cand.skip_bounded = True
+        elif o_filter is True:
+            cand.skip_invariant = True
+
+        return cand
+
+    # Default event handlers
+    def on_search_start(self, result):
+        pass
+
+    def on_search_complete(self, result):
+        pass
+
+
+# -----------------------------------------------------------------------------
+# ProgressTracker
+# -----------------------------------------------------------------------------
+
+class ProgressTracker(EventDispatcher):
+    '''Represents an ongoing (or completed) search operation. Instantiated and
+    returned by the :meth:`Recognizer.recognize` method when it is called. The
+    `results` attribute is a dictionary that is  updated as the recognition
+    operation progresses.
+
+    .. Note ::
+        You do not need to instantiate this class.
+
+    :Arguments:
+        `candidate`
+            :class:`Candidate` object to be evaluated
+        `tasks`
+            Total number of gestures in tasklist (to test against)
+
+    :Events:
+        `on_progress`
+            Fired for every gesture that is processed
+        `on_result`
+            Fired when a new result is added, and it is the first match
+            for the `name` so far, or a consecutive match with better score.
+        `on_complete`
+            Fired when the search is completed, for whatever reason.
+            (use `ProgressTracker.status` to find out)
+
+    :Attributes:
+        `results`
+            A dictionary of all results (so far). The key is the name of the
+            gesture (ie :attr:`UnistrokeTemplate.name` usually inherited from
+            :class:`MultistrokeGesture`). Each item in the dictionary is a
+            dict with the following entries:
+
+                `name`
+                    Name of the matched template (redundant)
+                `score`
+                    Computed score from 1.0 (perfect match) to 0.0
+                `dist`
+                    Cosine distance from candidate to template (low=closer)
+                `gesture`
+                    The :class:`MultistrokeGesture` object that was matched
+                `best_template`
+                    Index of the best matching template (in
+                    :attr:`MultistrokeGesture.templates`)
+                `template_results`
+                    List of distances for all templates. The list index
+                    corresponds to a :class:`UnistrokeTemplate` index in
+                    gesture.templates.
+
+        `status`
+            `search`
+                Currently working
+            `stop`
+                Was stopped by the user (:meth:`stop` called)
+            `timeout`
+                A timeout occurred (specified as `timeout=` to recognize())
+            `goodscore`
+                The search was stopped early because a gesture with a high
+                enough score was found (specified as `goodscore=` to
+                recognize())
+            `complete`
+                The search is complete (all gestures matching filters were
+                tested)
+    '''
+    def __init__(self, candidate, tasks, **kwargs):
+        self.status = 'search'
+        self.candidate = candidate
+        self.results = {}
+        self.tasks = tasks
+        self._start_time = Clock.get_time()
+        self._match_ops = 0
+        self._completed = 0
+        self._break_flag = False
+
+        # fired by recognize()
+        self.register_event_type('on_complete')
+        self.register_event_type('on_progress')
+
+        # fired locally
+        self.register_event_type('on_result')
+        super(ProgressTracker, self).__init__(**kwargs)
+
+    @property
+    def progress(self):
+        '''Returns the progress as a float, 0 is 0% done, 1 is 100%. This
+        is a Python property.'''
+        if not self.tasks:
+            return 1
+        return self._completed / float(self.tasks)
+
+    @property
+    def best(self):
+        '''Return the best match found by recognize() so far. It returns a
+        dictionary with three keys, 'name', 'dist' and 'score' representing
+        the template's name, distance (from candidate path) and the
+        computed score value. This is a Python property.'''
+        results = self.results  # to avoid too many self. lookups
+        if not results:
+            return {'name': None, 'dist': None, 'score': 0}
+        b = max(results, key=lambda r: results[r]['score'])
+        return {
+            'name': results[b]['name'],
+            'dist': results[b]['dist'],
+            'score': results[b]['score']
+        }
+
+    def stop(self):
+        '''Raises a stop flag that is checked by the search process. It will
+        be stopped on the next clock tick (if it is still running).'''
+        self._break_flag = True
+
+    def _add_result(self, gesture, dist, tpl, res):
+        # Add a result; used internally by the recognize() function
+        if tpl <= len(res):
+            n = gesture.templates[tpl].name
+        else:
+            return 0.
+
+        if n not in self.results or dist < self.results[n]['dist']:
+            self.results[n] = {
+                'name': n,
+                'dist': dist,
+                'gesture': gesture,
+                'best_template': tpl,
+                'template_results': res
+            }
+
+            if not dist:
+                self.results[n]['score'] = 1.0
+            else:
+                self.results[n]['score'] = 1.0 - (dist / pi)
+
+            self.dispatch('on_result', self.results[n])
+            return self.results[n]['score']
+        else:
+            return 0.
+
+    def on_complete(self):
+        pass
+
+    def on_progress(self):
+        pass
+
+    def on_result(self, result):
+        pass
+
+
+# -----------------------------------------------------------------------------
+# MultistrokeGesture
+# -----------------------------------------------------------------------------
+
+class MultistrokeGesture(object):
+    ''':class:`MultistrokeGesture` represents a gesture. It maintains a set of
+    `strokes` and generates unistroke (ie :class:`UnistrokeTemplate`)
+    permutations that are used for evaluating candidates against this gesture
+    later.
+
+    :Arguments:
+        `name`
+            Identifies the name of the gesture - it is returned to you in the
+            results of a :meth:`Recognizer.recognize` search. You can have any
+            number of MultistrokeGesture objects with the same name; many
+            definitions of one gesture. The same name is given to all the
+            generated unistroke permutations. Required, no default.
+        `strokes`
+            A list of paths that represents the gesture. A path is a list of
+            Vector objects::
+
+                gesture = MultistrokeGesture('my_gesture', strokes=[
+                  [Vector(x1, y1), Vector(x2, y2), ...... ], # stroke 1
+                  [Vector(), Vector(), Vector(), Vector() ]  # stroke 2
+                  #, [stroke 3], [stroke 4], ...
+                ])
+
+            For template matching purposes, all the strokes are combined to a
+            single list (unistroke). You should still specify the strokes
+            individually, and set `stroke_sensitive` True (whenever possible).
+
+            Once you do this, unistroke permutations are immediately generated
+            and stored in `self.templates` for later, unless you set the
+            `permute` flag to False.
+        `priority`
+            Determines when :func:`Recognizer.recognize` will attempt to match
+            this template, lower priorities are evaluated first (only if
+            a priority `filter` is used). You should use lower priority on
+            gestures that are more likely to match. For example, set user
+            templates at lower number than generic templates. Default is 100.
+        `numpoints`
+            Determines the number of points this gesture should be resampled to
+            (for matching purposes). The default is 16.
+        `stroke_sensitive`
+            Determines if the number of strokes (paths) in this gesture is
+            required to be the same in the candidate (user input) gesture
+            during matching. If this is False, candidates will always be
+            evaluated, disregarding the number of strokes. Default is True.
+        `orientation_sensitive`
+            Determines if this gesture is orientation sensitive. If True,
+            aligns the indicative orientation with the one of eight base
+            orientations that requires least rotation. Default is True.
+        `angle_similarity`
+            This is used by the :func:`Recognizer.recognize` function when a
+            candidate is evaluated against this gesture. If the angles between
+            them are too far off, the template is considered a non-match.
+            Default is 30.0 (degrees)
+        `permute`
+            If False, do not use Heap Permute algorithm to generate different
+            stroke orders when instantiated. If you set this to False, a
+            single UnistrokeTemplate built from `strokes` is used.
+    '''
+    def __init__(self, name, strokes=None, **kwargs):
+        self.name = name
+        self.priority = kwargs.get('priority', 100)
+        self.numpoints = kwargs.get('numpoints', 16)
+        self.stroke_sens = kwargs.get('stroke_sensitive', True)
+        self.orientation_sens = kwargs.get('orientation_sensitive', True)
+        self.angle_similarity = kwargs.get('angle_similarity', 30.0)
+        self.strokes = []
+
+        if strokes is not None:
+            self.strokes = strokes
+            if kwargs.get('permute', True):
+                self.permute()
+            else:
+                self.templates = [UnistrokeTemplate(name,
+                                  points=[i for sub in strokes for i in sub],
+                                  numpoints=self.numpoints,
+                                  orientation_sensitive=self.orientation_sens)]
+
+    def angle_similarity_threshold(self):
+        return radians(self.angle_similarity)
+
+    def add_stroke(self, stroke, permute=False):
+        '''Add a stroke to the self.strokes list. If `permute` is True, the
+        :meth:`permute` method is called to generate new unistroke templates'''
+        self.strokes.append(stroke)
+        if permute:
+            self.permute()
+
+    def get_distance(self, cand, tpl, numpoints=None):
+        '''Compute the distance from this Candidate to a UnistrokeTemplate.
+        Returns the Cosine distance between the stroke paths.
+
+        `numpoints` will prepare both the UnistrokeTemplate and Candidate path
+        to n points (when necessary), you probably don't want to do this.
+        '''
+        n = numpoints
+        if n is None or n < 2:
+            n = self.numpoints
+
+        # optimal_cosine_distance() inlined here for performance
+        v1 = tpl.get_vector(n)
+        v2 = cand.get_protractor_vector(n, tpl.orientation_sens)
+
+        a = 0.0
+        b = 0.0
+
+        for i in xrange(0, len(v1), 2):
+            a += (v1[i] * v2[i]) + (v1[i + 1] * v2[i + 1])
+            b += (v1[i] * v2[i + 1]) - (v1[i + 1] * v2[i])
+
+        angle = atan(b / a)
+
+        # If you put the below directly into math.acos(), you will get a domain
+        # error when a=1.0 and angle=0.0 (ie math_cos(angle)=1.0). It seems to
+        # be because float representation of 1.0*1.0 is >1.0 (ie 1.00000...001)
+        # and this is problematic for math.acos().
+        # If you try math.acos(1.0*1.0) in interpreter it does not happen,
+        # only with exact match at runtime
+        result = a * math_cos(angle) + b * math_sin(angle)
+
+        # FIXME: I'm sure there is a better way to do it but..
+        if result >= 1:
+            result = 1
+        elif result <= -1:  # has not happened to me, but I leave it here.
+            result = -1
+        return acos(result)
+
+    def match_candidate(self, cand, **kwargs):
+        '''Match a given candidate against this MultistrokeGesture object. Will
+        test against all templates and report results as a list of four
+        items:
+
+            `index 0`
+                Best matching template's index (in self.templates)
+            `index 1`
+                Computed distance from the template to the candidate path
+            `index 2`
+                List of distances for all templates. The list index
+                corresponds to a :class:`UnistrokeTemplate` index in
+                self.templates.
+            `index 3`
+                Counter for the number of performed matching operations, ie
+                templates matched against the candidate
+        '''
+        best_d = float('infinity')
+        best_tpl = None
+        mos = 0
+        out = []
+
+        if (self.stroke_sens and len(self.strokes) != len(cand.strokes)):
+            return (best_tpl, best_d, out, mos)
+
+        skip_bounded = cand.skip_bounded
+        skip_invariant = cand.skip_invariant
+        get_distance = self.get_distance
+        ang_sim_threshold = self.angle_similarity_threshold()
+
+        for idx, tpl in enumerate(self.templates):
+            # Handle a theoretical case where a MultistrokeGesture is composed
+            # manually and the orientation_sensitive flag is True, and contains
+            # a UnistrokeTemplate that has orientation_sensitive=False (or vice
+            # versa). This would cause KeyError - requesting nonexistent vector
+            if tpl.orientation_sens:
+                if skip_bounded:
+                    continue
+            elif skip_invariant:
+                continue
+
+            # Count as a match operation now, since the call to get_
+            # angle_similarity below will force vector calculation,
+            # even if it doesn't make it to get_distance
+            mos += 1
+
+            # Note: With this implementation, we always resample the candidate
+            # to *any* encountered UnistrokeTemplate numpoints here, the filter
+            # is only applied to MultistrokeGesture. See theoretical case
+            # above; should not matter normally.
+            n = kwargs.get('force_numpoints', tpl.numpoints)
+
+            # Skip if candidate/gesture angles are too far off
+            ang_sim = cand.get_angle_similarity(tpl, numpoints=n)
+            if ang_sim > ang_sim_threshold:
+                continue
+
+            # Get the distance between cand/tpl paths
+            d = get_distance(cand, tpl, numpoints=n)
+            out.append(d)
+
+            if d < best_d:
+                best_d = d
+                best_tpl = idx
+
+        return (best_tpl, best_d, out, mos)
+
+    def permute(self):
+        '''Generate all possible unistroke permutations from self.strokes and
+        save the resulting list of UnistrokeTemplate objects in self.templates.
+
+        Quote from http://faculty.washington.edu/wobbrock/pubs/gi-10.2.pdf ::
+
+            We use Heap Permute [16] (p. 179) to generate all stroke orders
+            in a multistroke gesture. Then, to generate stroke directions for
+            each order, we treat each component stroke as a dichotomous
+            [0,1] variable. There are 2^N combinations for N strokes, so we
+            convert the decimal values 0 to 2^N-1, inclusive, to binary
+            representations and regard each bit as indicating forward (0) or
+            reverse (1). This algorithm is often used to generate truth tables
+            in propositional logic.
+
+        See section 4.1: "$N Algorithm" of the linked paper for details.
+
+        .. Warning ::
+
+            Using heap permute for gestures with more than 3 strokes
+            can result in very large number of templates (a 9-stroke
+            gesture = 38 million templates). If you are dealing with
+            these types of gestures, you should manually compose
+            all the desired stroke orders.
+        '''
+        # Seed with index of each stroke
+        self._order = [i for i in xrange(0, len(self.strokes))]
+
+        # Prepare ._orders
+        self._orders = []
+        self._heap_permute(len(self.strokes))
+        del self._order
+
+        # Generate unistroke permutations
+        self.templates = [UnistrokeTemplate(
+            self.name,
+            points=permutation,
+            numpoints=self.numpoints,
+            orientation_sensitive=self.orientation_sens
+        ) for permutation in self._make_unistrokes()]
+        del self._orders
+
+    def _heap_permute(self, n):
+        # Heap Permute algorithm
+        self_order = self._order
+        if n == 1:
+            self._orders.append(self_order[:])
+        else:
+            i = 0
+            for i in xrange(0, n):
+                self._heap_permute(n - 1)
+                if n % 2 == 1:
+                    tmp = self_order[0]
+                    self_order[0] = self_order[n - 1]
+                    self_order[n - 1] = tmp
+                else:
+                    tmp = self_order[i]
+                    self_order[i] = self_order[n - 1]
+                    self_order[n - 1] = tmp
+
+    def _make_unistrokes(self):
+        # Create unistroke permutations from self.strokes
+        unistrokes = []
+        unistrokes_append = unistrokes.append
+        self_strokes = self.strokes
+        for r in self._orders:
+            b = 0
+            while b < pow(2, len(r)):  # use b's bits for directions
+                unistroke = []
+                unistroke_append = unistroke.append
+                for i in xrange(0, len(r)):
+                    pts = self_strokes[r[i]][:]
+                    if (b >> i) & 1 == 1:  # is b's bit at index i 1?
+                        pts.reverse()
+                    unistroke_append(None)
+                    unistroke[-1:] = pts
+
+                unistrokes_append(unistroke)
+                b += 1
+        return unistrokes
+
+
+# -----------------------------------------------------------------------------
+# UnistrokeTemplate
+# -----------------------------------------------------------------------------
+
+class UnistrokeTemplate(object):
+    '''Represents a (uni)stroke path as a list of Vectors. Normally, this class
+    is instantiated by MultistrokeGesture and not by the programmer directly.
+    However, it is possible to manually compose UnistrokeTemplate objects.
+
+    :Arguments:
+        `name`
+            Identifies the name of the gesture. This is normally inherited from
+            the parent MultistrokeGesture object when a template is generated.
+        `points`
+            A list of points that represents a unistroke path. This is normally
+            one of the possible stroke order permutations from a
+            MultistrokeGesture.
+        `numpoints`
+            The number of points this template should (ideally) be resampled to
+            before the matching process. The default is 16, but you can use a
+            template-specific settings if that improves results.
+        `orientation_sensitive`
+            Determines if this template is orientation sensitive (True) or
+            fully rotation invariant (False). The default is True.
+
+    .. Note::
+        You will get an exception if you set a skip-flag and then attempt to
+        retrieve those vectors.
+    '''
+    def __init__(self, name, points=None, **kwargs):
+        self.name = name
+        self.numpoints = kwargs.get('numpoints', 16)
+        self.orientation_sens = kwargs.get('orientation_sensitive', True)
+
+        self.db = {}
+        self.points = []
+
+        if points is not None:
+            self.points = points
+
+    def add_point(self, p):
+        '''Add a point to the unistroke/path. This invalidates all previously
+        computed vectors.'''
+        self.points.append(p)
+        # All previously computed data is now void.
+        self.db = {}
+
+    # Used to lazily prepare the template
+    def _get_db_key(self, key, numpoints=None):
+        n = numpoints and numpoints or self.numpoints
+        if n not in self.db:
+            self.prepare(n)
+        return self.db[n][key]
+
+    def get_start_unit_vector(self, numpoints=None):
+        return self._get_db_key('startvector', numpoints)
+
+    def get_vector(self, numpoints=None):
+        return self._get_db_key('vector', numpoints)
+
+    def get_points(self, numpoints=None):
+        return self._get_db_key('points', numpoints)
+
+    def prepare(self, numpoints=None):
+        '''This function prepares the UnistrokeTemplate for matching given a
+        target number of points (for resample). 16 is optimal.'''
+
+        if not self.points:
+            raise MultistrokeError('prepare() called without self.points')
+
+        # How many points are we resampling to?
+        n = numpoints or self.numpoints
+        if not n or n < 2:
+            raise MultistrokeError('prepare() called with invalid numpoints')
+
+        p = resample(self.points, n)
+        radians = indicative_angle(p)
+        p = rotate_by(p, -radians)
+        p = scale_dim(p, SQUARESIZE, ONEDTHRESHOLD)
+
+        if self.orientation_sens:
+            p = rotate_by(p, +radians)  # restore
+
+        p = translate_to(p, ORIGIN)
+
+        # Now store it using the number of points in the resampled path as the
+        # dict key. On the next call to get_*, it will be returned instead of
+        # recomputed. Implicitly, you must reset self.db or call prepare() for
+        # all the keys once you manipulate self.points.
+        self.db[n] = {
+            # Compute STARTANGLEINDEX as n/8:
+            'startvector': start_unit_vector(p, (n / 8)),
+            'vector': vectorize(p, self.orientation_sens)
+        }
+
+
+# -----------------------------------------------------------------------------
+# Candidate
+# -----------------------------------------------------------------------------
+
+class Candidate(object):
+    '''Represents a set of unistroke paths of user input, ie data to be matched
+    against a :class:`UnistrokeTemplate` object using the Protractor algorithm.
+    By default, data is precomputed to match both rotation bounded and fully
+    invariant :class:`UnistrokeTemplate` objects.
+
+    :Arguments:
+        `strokes`
+            See :data:`MultistrokeGesture.strokes` for format example. The
+            Candidate strokes are simply combined to a unistroke in the order
+            given. The idea is that this will match one of the unistroke
+            permutations in `MultistrokeGesture.templates`.
+        `numpoints`
+            The Candidate's default N; this is only for a fallback, it is not
+            normally used since n is driven by the UnistrokeTemplate we are
+            being compared to.
+        `skip_bounded`
+            If True, do not generate/store rotation bounded vectors
+        `skip_invariant`
+            If True, do not generate/store rotation invariant vectors
+
+    Note that you WILL get errors if you set a skip-flag and then attempt to
+    retrieve the data.'''
+    def __init__(self, strokes=None, numpoints=16, **kwargs):
+        self.skip_invariant = kwargs.get('skip_invariant', False)
+        self.skip_bounded = kwargs.get('skip_bounded', False)
+
+        self.numpoints = numpoints
+        self.db = {}
+        self.strokes = []
+
+        if strokes is not None:
+            self.strokes = strokes
+
+    def add_stroke(self, stroke):
+        '''Add a stroke to the candidate; this will invalidate all
+        previously computed vectors'''
+        self.points.append(stroke)
+        self.db = {}
+
+    # Used to lazily prepare the candidate
+    def _get_db_key(self, key, numpoints, orientation_sens):
+        n = numpoints and numpoints or self.numpoints
+        if n not in self.db:
+            self.prepare(n)
+
+        prefix = orientation_sens and 'bound_' or 'inv_'
+        return self.db[n][prefix + key]
+
+    def get_start_unit_vector(self, numpoints, orientation_sens):
+        '''(Internal use only) Get the start vector for this Candidate,
+        with the path resampled to `numpoints` points. This is the first
+        step in the matching process. It is compared to a
+        UnistrokeTemplate object's start vector to determine angle
+        similarity.'''
+        return self._get_db_key('startvector', numpoints, orientation_sens)
+
+    def get_protractor_vector(self, numpoints, orientation_sens):
+        '''(Internal use only) Return vector for comparing to a
+        UnistrokeTemplate with Protractor'''
+        return self._get_db_key('vector', numpoints, orientation_sens)
+
+    def get_angle_similarity(self, tpl, **kwargs):
+        '''(Internal use only) Compute the angle similarity between this
+        Candidate and a UnistrokeTemplate object. Returns a number that
+        represents the angle similarity (lower is more similar).'''
+        n = kwargs.get('numpoints', self.numpoints)
+
+        # angle_between_unit_vectors() inlined here for performance
+        v1x, v1y = self.get_start_unit_vector(n, tpl.orientation_sens)
+        v2x, v2y = tpl.get_start_unit_vector(n)
+
+        n = (v1x * v2x + v1y * v2y)
+        # FIXME: Domain error on float representation of 1.0 (exact match)
+        # (see comments in MultistrokeGesture.get_distance())
+        if n >= 1:
+            return 0.0
+        if n <= -1:
+            return pi
+        return acos(n)
+
+    def prepare(self, numpoints=None):
+        '''Prepare the Candidate vectors. self.strokes is combined to a single
+        unistroke (connected end-to-end), resampled to :attr:`numpoints`
+        points, and then the vectors are calculated and stored in self.db (for
+        use by `get_distance` and `get_angle_similarity`)'''
+        n = numpoints and numpoints or self.numpoints
+
+        # Inlined combine_strokes() for performance
+        points = [i for sub in self.strokes for i in sub]
+        points = resample(points, n)
+        radians = indicative_angle(points)
+        points = rotate_by(points, -radians)
+        points = scale_dim(points, SQUARESIZE, ONEDTHRESHOLD)
+
+        # Compute STARTANGLEINDEX as n / 8
+        angidx = n / 8
+        cand = {}
+
+        # full rotation invariance
+        if not self.skip_invariant:
+            inv_points = translate_to(points, ORIGIN)
+            cand['inv_startvector'] = start_unit_vector(inv_points, angidx)
+            cand['inv_vector'] = vectorize(inv_points, False)
+
+        # rotation bounded invariance
+        if not self.skip_bounded:
+            bound_points = rotate_by(points, +radians)  # restore
+            bound_points = translate_to(bound_points, ORIGIN)
+            cand['bound_startvector'] = start_unit_vector(bound_points, angidx)
+            cand['bound_vector'] = vectorize(bound_points, True)
+
+        self.db[n] = cand
+
+
+# -----------------------------------------------------------------------------
+# Helper functions from this point on. This is all directly related to the
+# recognition algorithm, and is almost 100% transcription from the JavaScript
+# -----------------------------------------------------------------------------
+def resample(points, n):
+    # Resample a path to `n` points
+    if not len(points) or not n or n < 2:
+        raise MultistrokeError('resample() called with invalid arguments')
+
+    interval = path_length(points) / (n - 1)
+    D = 0.0
+    i = 1
+    newpoints = [points[0]]
+    workpoints = points[:]
+    newpoints_len = 1
+    workpoints_len = len(points)
+
+    new_append = newpoints.append
+    work_insert = workpoints.insert
+    while i < len(workpoints):
+        p1 = workpoints[i - 1]
+        p2 = workpoints[i]
+        d = distance(p1, p2)
+
+        if D + d >= interval:
+            qx = p1[0] + ((interval - D) / d) * (p2[0] - p1[0])
+            qy = p1[1] + ((interval - D) / d) * (p2[1] - p1[1])
+            q = Vector(qx, qy)
+            new_append(q)
+            work_insert(i, q)  # q is the next i
+            newpoints_len += 1
+            workpoints_len += 1
+            D = 0.0
+        else:
+            D += d
+
+        i += 1
+
+    # rounding error; insert the last point
+    if newpoints_len < n:
+        new_append(points[-1])
+
+    return newpoints
+
+
+def indicative_angle(points):
+    cx, cy = centroid(points)
+    return atan2(cy - points[0][1], cx - points[0][0])
+
+
+def rotate_by(points, radians):
+    # Rotate points around centroid
+    cx, cy = centroid(points)
+    cos = math_cos(radians)
+    sin = math_sin(radians)
+    newpoints = []
+    newpoints_append = newpoints.append
+
+    for i in xrange(0, len(points)):
+        qx = (points[i][0] - cx) * cos - (points[i][1] - cy) * sin + cx
+        qy = (points[i][0] - cx) * sin + (points[i][1] - cy) * cos + cy
+        newpoints_append(Vector(qx, qy))
+
+    return newpoints
+
+
+def scale_dim(points, size, oneDratio):
+    bbox_x, bbox_y, bbox_w, bbox_h = bounding_box(points)
+
+    if bbox_h == 0 or bbox_w == 0:
+        raise MultistrokeError(
+            'scale_dim() called with invalid points: h:{}, w:{}'
+            .format(bbox_h, bbox_w))
+
+    # 1D or 2D gesture test
+    uniformly = min(bbox_w / bbox_h, bbox_h / bbox_w) <= oneDratio
+
+    if uniformly:
+        qx_size = size / max(bbox_w, bbox_h)
+        qy_size = size / max(bbox_w, bbox_h)
+    else:
+        qx_size = size / bbox_w
+        qy_size = size / bbox_h
+
+    newpoints = []
+    newpoints_append = newpoints.append
+
+    for p in points:
+        qx = p[0] * qx_size
+        qy = p[1] * qy_size
+        newpoints_append(Vector(qx, qy))
+
+    return newpoints
+
+
+def translate_to(points, pt):
+    # Translate points around centroid
+    cx, cy = centroid(points)
+    ptx, pty = pt
+    newpoints = []
+    for p in points:
+        qx = p[0] + ptx - cx
+        qy = p[1] + pty - cy
+        newpoints.append(Vector(qx, qy))
+    return newpoints
+
+
+def vectorize(points, use_bounded_rotation_invariance):
+    # Helper function for the Protractor algorithm
+    cos = 1.0
+    sin = 0.0
+
+    if use_bounded_rotation_invariance:
+        ang = atan2(points[0][1], points[0][0])
+        bo = (pi / 4.) * floor((ang + pi / 8.) / (pi / 4.))
+        cos = math_cos(bo - ang)
+        sin = math_sin(bo - ang)
+
+    sum = 0.0
+    vector = []
+    vector_len = 0
+    vector_append = vector.append
+
+    for px, py in points:
+        newx = px * cos - py * sin
+        newy = py * cos + px * sin
+        vector_append(newx)
+        vector_append(newy)
+        vector_len += 2
+        sum += newx ** 2 + newy ** 2
+
+    magnitude = sqrt(sum)
+    for i in xrange(0, vector_len):
+        vector[i] /= magnitude
+
+    return vector
+
+
+def centroid(points):
+    x = 0.0
+    y = 0.0
+    points_len = len(points)
+
+    for i in xrange(0, points_len):
+        x += points[i][0]
+        y += points[i][1]
+
+    x /= points_len
+    y /= points_len
+
+    return Vector(x, y)
+
+
+def bounding_box(points):
+    minx = float('infinity')
+    miny = float('infinity')
+    maxx = float('-infinity')
+    maxy = float('-infinity')
+
+    for px, py in points:
+        if px < minx:
+            minx = px
+        if px > maxx:
+            maxx = px
+        if py < miny:
+            miny = py
+        if py > maxy:
+            maxy = py
+
+    return (minx, miny, maxx - minx + 1, maxy - miny + 1)
+
+
+def path_length(points):
+    d = 0.0
+    for i in xrange(1, len(points)):
+        d += distance(points[i - 1], points[i])
+    return d
+
+
+def distance(p1, p2):
+    dx = p2[0] - p1[0]
+    dy = p2[1] - p1[1]
+    return sqrt(dx ** 2 + dy ** 2)
+
+
+def start_unit_vector(points, index):
+    i = int(index)
+    vx, vy = points[i][0] - points[0][0], points[i][1] - points[0][1]
+    length = sqrt(vx ** 2 + vy ** 2)
+    return Vector(vx / length, vy / length)
diff --git a/kivy/network/__init__.py b/kivy/network/__init__.py
new file mode 100644
index 0000000..4984587
--- /dev/null
+++ b/kivy/network/__init__.py
@@ -0,0 +1,7 @@
+'''
+Network support
+===============
+
+Kivy currently supports basic, asynchronous network requests.
+Please refer to :class:`kivy.network.urlrequest.UrlRequest`.
+'''
diff --git a/kivy/network/__pycache__/__init__.cpython-310.pyc b/kivy/network/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..87f1178
Binary files /dev/null and b/kivy/network/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/network/__pycache__/urlrequest.cpython-310.pyc b/kivy/network/__pycache__/urlrequest.cpython-310.pyc
new file mode 100644
index 0000000..c2fc28e
Binary files /dev/null and b/kivy/network/__pycache__/urlrequest.cpython-310.pyc differ
diff --git a/kivy/network/urlrequest.py b/kivy/network/urlrequest.py
new file mode 100644
index 0000000..7956195
--- /dev/null
+++ b/kivy/network/urlrequest.py
@@ -0,0 +1,658 @@
+'''
+UrlRequest
+==========
+
+.. versionadded:: 1.0.8
+
+You can use the :class:`UrlRequest` to make asynchronous requests on the
+web and get the result when the request is completed. The spirit is the
+same as the XHR object in Javascript.
+
+The content is also decoded if the Content-Type is
+application/json and the result automatically passed through json.loads.
+
+
+The syntax to create a request::
+
+    from kivy.network.urlrequest import UrlRequest
+    req = UrlRequest(url, on_success, on_redirect, on_failure, on_error,
+                     on_progress, req_body, req_headers, chunk_size,
+                     timeout, method, decode, debug, file_path, ca_file,
+                     verify)
+
+
+Only the first argument is mandatory: the rest are optional.
+By default, a "GET" request will be sent. If the :attr:`UrlRequest.req_body` is
+not None, a "POST" request will be sent. It's up to you to adjust
+:attr:`UrlRequest.req_headers` to suit your requirements and the response
+to the request will be accessible as the parameter called "result" on
+the callback function of the on_success event.
+
+
+Example of fetching JSON::
+
+    def got_json(req, result):
+        for key, value in req.resp_headers.items():
+            print('{}: {}'.format(key, value))
+
+    req = UrlRequest('https://httpbin.org/headers', got_json)
+
+Example of Posting data (adapted from httplib example)::
+
+    import urllib
+
+    def bug_posted(req, result):
+        print('Our bug is posted!')
+        print(result)
+
+    params = urllib.urlencode({'@number': 12524, '@type': 'issue',
+        '@action': 'show'})
+    headers = {'Content-type': 'application/x-www-form-urlencoded',
+              'Accept': 'text/plain'}
+    req = UrlRequest('bugs.python.org', on_success=bug_posted, req_body=params,
+            req_headers=headers)
+
+If you want a synchronous request, you can call the wait() method.
+
+'''
+
+from base64 import b64encode
+from collections import deque
+from threading import Thread, Event
+from json import loads
+from time import sleep
+from kivy.compat import PY2
+from kivy.config import Config
+
+if PY2:
+    from httplib import HTTPConnection
+    from urlparse import urlparse, urlunparse
+else:
+    from http.client import HTTPConnection
+    from urllib.parse import urlparse, urlunparse
+
+try:
+    import ssl
+
+    HTTPSConnection = None
+    if PY2:
+        from httplib import HTTPSConnection
+    else:
+        from http.client import HTTPSConnection
+except ImportError:
+    # depending the platform, if openssl support wasn't compiled before python,
+    # this class is not available.
+    pass
+
+from kivy.clock import Clock
+from kivy.weakmethod import WeakMethod
+from kivy.logger import Logger
+from kivy.utils import platform
+
+
+# list to save UrlRequest and prevent GC on un-referenced objects
+g_requests = []
+
+
+class UrlRequest(Thread):
+    '''A UrlRequest. See module documentation for usage.
+
+    .. versionchanged:: 1.5.1
+        Add `debug` parameter
+
+    .. versionchanged:: 1.0.10
+        Add `method` parameter
+
+    .. versionchanged:: 1.8.0
+
+        Parameter `decode` added.
+        Parameter `file_path` added.
+        Parameter `on_redirect` added.
+        Parameter `on_failure` added.
+
+    .. versionchanged:: 1.9.1
+
+        Parameter `ca_file` added.
+        Parameter `verify` added.
+
+    .. versionchanged:: 1.10.0
+
+        Parameters `proxy_host`, `proxy_port` and `proxy_headers` added.
+
+    .. versionchanged:: 1.11.0
+
+        Parameters `on_cancel` added.
+
+    :Parameters:
+        `url`: str
+            Complete url string to call.
+        `on_success`: callback(request, result)
+            Callback function to call when the result has been fetched.
+        `on_redirect`: callback(request, result)
+            Callback function to call if the server returns a Redirect.
+        `on_failure`: callback(request, result)
+            Callback function to call if the server returns a Client or
+            Server Error.
+        `on_error`: callback(request, error)
+            Callback function to call if an error occurs.
+        `on_progress`: callback(request, current_size, total_size)
+            Callback function that will be called to report progression of the
+            download. `total_size` might be -1 if no Content-Length has been
+            reported in the http response.
+            This callback will be called after each `chunk_size` is read.
+        `on_cancel`: callback(request)
+            Callback function to call if user requested to cancel the download
+            operation via the .cancel() method.
+        `req_body`: str, defaults to None
+            Data to sent in the request. If it's not None, a POST will be done
+            instead of a GET.
+        `req_headers`: dict, defaults to None
+            Custom headers to add to the request.
+        `chunk_size`: int, defaults to 8192
+            Size of each chunk to read, used only when `on_progress` callback
+            has been set. If you decrease it too much, a lot of on_progress
+            callbacks will be fired and will slow down your download. If you
+            want to have the maximum download speed, increase the chunk_size
+            or don't use ``on_progress``.
+        `timeout`: int, defaults to None
+            If set, blocking operations will timeout after this many seconds.
+        `method`: str, defaults to 'GET' (or 'POST' if ``body`` is specified)
+            The HTTP method to use.
+        `decode`: bool, defaults to True
+            If False, skip decoding of the response.
+        `debug`: bool, defaults to False
+            If True, it will use the Logger.debug to print information
+            about url access/progression/errors.
+        `file_path`: str, defaults to None
+            If set, the result of the UrlRequest will be written to this path
+            instead of in memory.
+        `ca_file`: str, defaults to None
+            Indicates a SSL CA certificate file path to validate HTTPS
+            certificates against
+        `verify`: bool, defaults to True
+            If False, disables SSL CA certificate verification
+        `proxy_host`: str, defaults to None
+            If set, the proxy host to use for this connection.
+        `proxy_port`: int, defaults to None
+            If set, and `proxy_host` is also set, the port to use for
+            connecting to the proxy server.
+        `proxy_headers`: dict, defaults to None
+            If set, and `proxy_host` is also set, the headers to send to the
+            proxy server in the ``CONNECT`` request.
+    '''
+
+    def __init__(self, url, on_success=None, on_redirect=None,
+                 on_failure=None, on_error=None, on_progress=None,
+                 req_body=None, req_headers=None, chunk_size=8192,
+                 timeout=None, method=None, decode=True, debug=False,
+                 file_path=None, ca_file=None, verify=True, proxy_host=None,
+                 proxy_port=None, proxy_headers=None, user_agent=None,
+                 on_cancel=None, cookies=None):
+        super(UrlRequest, self).__init__()
+        self._queue = deque()
+        self._trigger_result = Clock.create_trigger(self._dispatch_result, 0)
+        self.daemon = True
+        self.on_success = WeakMethod(on_success) if on_success else None
+        self.on_redirect = WeakMethod(on_redirect) if on_redirect else None
+        self.on_failure = WeakMethod(on_failure) if on_failure else None
+        self.on_error = WeakMethod(on_error) if on_error else None
+        self.on_progress = WeakMethod(on_progress) if on_progress else None
+        self.on_cancel = WeakMethod(on_cancel) if on_cancel else None
+        self.decode = decode
+        self.file_path = file_path
+        self._debug = debug
+        self._result = None
+        self._error = None
+        self._is_finished = False
+        self._resp_status = None
+        self._resp_headers = None
+        self._resp_length = -1
+        self._chunk_size = chunk_size
+        self._timeout = timeout
+        self._method = method
+        self.verify = verify
+        self._proxy_host = proxy_host
+        self._proxy_port = proxy_port
+        self._proxy_headers = proxy_headers
+        self._cancel_event = Event()
+        self._user_agent = user_agent
+        self._cookies = cookies
+
+        if platform in ['android', 'ios']:
+            import certifi
+            self.ca_file = ca_file or certifi.where()
+        else:
+            self.ca_file = ca_file
+
+        #: Url of the request
+        self.url = url
+
+        #: Request body passed in __init__
+        self.req_body = req_body
+
+        #: Request headers passed in __init__
+        self.req_headers = req_headers
+
+        # save our request to prevent GC
+        g_requests.append(self)
+
+        self.start()
+
+    def run(self):
+        q = self._queue.appendleft
+        url = self.url
+        req_body = self.req_body
+        req_headers = self.req_headers or {}
+
+        user_agent = self._user_agent
+        cookies = self._cookies
+
+        if user_agent:
+            req_headers.setdefault('User-Agent', user_agent)
+
+        elif (
+            Config.has_section('network')
+            and 'useragent' in Config.items('network')
+        ):
+            useragent = Config.get('network', 'useragent')
+            req_headers.setdefault('User-Agent', useragent)
+
+        if cookies:
+            req_headers.setdefault("Cookie", cookies)
+
+        try:
+            result, resp = self._fetch_url(url, req_body, req_headers, q)
+            if self.decode:
+                result = self.decode_result(result, resp)
+        except Exception as e:
+            q(('error', None, e))
+        else:
+            if not self._cancel_event.is_set():
+                q(('success', resp, result))
+            else:
+                q(('killed', None, None))
+
+        # using trigger can result in a missed on_success event
+        self._trigger_result()
+
+        # clean ourself when the queue is empty
+        while len(self._queue):
+            sleep(.1)
+            self._trigger_result()
+
+        # ok, authorize the GC to clean us.
+        if self in g_requests:
+            g_requests.remove(self)
+
+    def _parse_url(self, url):
+        parse = urlparse(url)
+        host = parse.hostname
+        port = parse.port
+        userpass = None
+
+        # append user + pass to hostname if specified
+        if parse.username and parse.password:
+            userpass = {
+                "Authorization": "Basic {}".format(b64encode(
+                    "{}:{}".format(
+                        parse.username,
+                        parse.password
+                    ).encode('utf-8')
+                ).decode('utf-8'))
+            }
+
+        return host, port, userpass, parse
+
+    def _fetch_url(self, url, body, headers, q):
+        # Parse and fetch the current url
+        trigger = self._trigger_result
+        chunk_size = self._chunk_size
+        report_progress = self.on_progress is not None
+        timeout = self._timeout
+        file_path = self.file_path
+        ca_file = self.ca_file
+        verify = self.verify
+
+        if self._debug:
+            Logger.debug('UrlRequest: {0} Fetch url <{1}>'.format(
+                id(self), url))
+            Logger.debug('UrlRequest: {0} - body: {1}'.format(
+                id(self), body))
+            Logger.debug('UrlRequest: {0} - headers: {1}'.format(
+                id(self), headers))
+
+        # parse url
+        host, port, userpass, parse = self._parse_url(url)
+        if userpass and not headers:
+            headers = userpass
+        elif userpass and headers:
+            key = list(userpass.keys())[0]
+            headers[key] = userpass[key]
+
+        # translate scheme to connection class
+        cls = self.get_connection_for_scheme(parse.scheme)
+
+        # reconstruct path to pass on the request
+        path = parse.path
+        if parse.params:
+            path += ';' + parse.params
+        if parse.query:
+            path += '?' + parse.query
+        if parse.fragment:
+            path += '#' + parse.fragment
+
+        # create connection instance
+        args = {}
+        if timeout is not None:
+            args['timeout'] = timeout
+
+        if (ca_file is not None and hasattr(ssl, 'create_default_context') and
+                parse.scheme == 'https'):
+            ctx = ssl.create_default_context(cafile=ca_file)
+            ctx.verify_mode = ssl.CERT_REQUIRED
+            args['context'] = ctx
+
+        if not verify and parse.scheme == 'https' and (
+            hasattr(ssl, 'create_default_context')):
+            ctx = ssl.create_default_context()
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+            args['context'] = ctx
+
+        if self._proxy_host:
+            Logger.debug('UrlRequest: {0} - proxy via {1}:{2}'.format(
+                id(self), self._proxy_host, self._proxy_port
+            ))
+            req = cls(self._proxy_host, self._proxy_port, **args)
+            if parse.scheme == 'https':
+                req.set_tunnel(host, port, self._proxy_headers)
+            else:
+                path = urlunparse(parse)
+        else:
+            req = cls(host, port, **args)
+
+        # send request
+        method = self._method
+        if method is None:
+            method = 'GET' if body is None else 'POST'
+        req.request(method, path, body, headers or {})
+
+        # read header
+        resp = req.getresponse()
+
+        # read content
+        if report_progress or file_path is not None:
+            try:
+                total_size = int(resp.getheader('content-length'))
+            except:
+                total_size = -1
+
+            # before starting the download, send a fake progress to permit the
+            # user to initialize his ui
+            if report_progress:
+                q(('progress', resp, (0, total_size)))
+
+            def get_chunks(fd=None):
+                bytes_so_far = 0
+                result = b''
+                while 1:
+                    chunk = resp.read(chunk_size)
+                    if not chunk:
+                        break
+
+                    if fd:
+                        fd.write(chunk)
+                    else:
+                        result += chunk
+
+                    bytes_so_far += len(chunk)
+                    # report progress to user
+                    if report_progress:
+                        q(('progress', resp, (bytes_so_far, total_size)))
+                        trigger()
+                    if self._cancel_event.is_set():
+                        break
+                return bytes_so_far, result
+
+            if file_path is not None:
+                with open(file_path, 'wb') as fd:
+                    bytes_so_far, result = get_chunks(fd)
+            else:
+                bytes_so_far, result = get_chunks()
+
+            # ensure that results are dispatched for the last chunk,
+            # avoid trigger
+            if report_progress:
+                q(('progress', resp, (bytes_so_far, total_size)))
+                trigger()
+        else:
+            result = resp.read()
+            try:
+                if isinstance(result, bytes):
+                    result = result.decode('utf-8')
+            except UnicodeDecodeError:
+                # if it's an image? decoding would not work
+                pass
+        req.close()
+
+        # return everything
+        return result, resp
+
+    def get_connection_for_scheme(self, scheme):
+        '''Return the Connection class for a particular scheme.
+        This is an internal function that can be expanded to support custom
+        schemes.
+
+        Actual supported schemes: http, https.
+        '''
+        if scheme == 'http':
+            return HTTPConnection
+        elif scheme == 'https' and HTTPSConnection is not None:
+            return HTTPSConnection
+        else:
+            raise Exception('No class for scheme %s' % scheme)
+
+    def decode_result(self, result, resp):
+        '''Decode the result fetched from url according to his Content-Type.
+        Currently supports only application/json.
+        '''
+        # Entry to decode url from the content type.
+        # For example, if the content type is a json, it will be automatically
+        # decoded.
+        content_type = resp.getheader('Content-Type', None)
+        if content_type is not None:
+            ct = content_type.split(';')[0]
+            if ct == 'application/json':
+                if isinstance(result, bytes):
+                    result = result.decode('utf-8')
+                try:
+                    return loads(result)
+                except:
+                    return result
+
+        return result
+
+    def _dispatch_result(self, dt):
+        while True:
+            # Read the result pushed on the queue, and dispatch to the client
+            try:
+                result, resp, data = self._queue.pop()
+            except IndexError:
+                return
+            if resp:
+                # Small workaround in order to prevent the situation mentioned
+                # in the comment below
+                final_cookies = ""
+                parsed_headers = []
+                for key, value in resp.getheaders():
+                    if key == "Set-Cookie":
+                        final_cookies += "{};".format(value)
+                    else:
+                        parsed_headers.append((key, value))
+                parsed_headers.append(("Set-Cookie", final_cookies[:-1]))
+
+                # XXX usage of dict can be dangerous if multiple headers
+                # are set even if it's invalid. But it look like it's ok
+                # ?  http://stackoverflow.com/questions/2454494/..
+                # ..urllib2-multiple-set-cookie-headers-in-response
+                self._resp_headers = dict(parsed_headers)
+                self._resp_status = resp.status
+            if result == 'success':
+                status_class = resp.status // 100
+
+                if status_class in (1, 2):
+                    if self._debug:
+                        Logger.debug('UrlRequest: {0} Download finished with'
+                                     ' {1} datalen'.format(id(self),
+                                                           len(data)))
+                    self._is_finished = True
+                    self._result = data
+                    if self.on_success:
+                        func = self.on_success()
+                        if func:
+                            func(self, data)
+
+                elif status_class == 3:
+                    if self._debug:
+                        Logger.debug('UrlRequest: {} Download '
+                                     'redirected'.format(id(self)))
+                    self._is_finished = True
+                    self._result = data
+                    if self.on_redirect:
+                        func = self.on_redirect()
+                        if func:
+                            func(self, data)
+
+                elif status_class in (4, 5):
+                    if self._debug:
+                        Logger.debug('UrlRequest: {} Download failed with '
+                                     'http error {}'.format(id(self),
+                                                            resp.status))
+                    self._is_finished = True
+                    self._result = data
+                    if self.on_failure:
+                        func = self.on_failure()
+                        if func:
+                            func(self, data)
+
+            elif result == 'error':
+                if self._debug:
+                    Logger.debug('UrlRequest: {0} Download error '
+                                 '<{1}>'.format(id(self), data))
+                self._is_finished = True
+                self._error = data
+                if self.on_error:
+                    func = self.on_error()
+                    if func:
+                        func(self, data)
+
+            elif result == 'progress':
+                if self._debug:
+                    Logger.debug('UrlRequest: {0} Download progress '
+                                 '{1}'.format(id(self), data))
+                if self.on_progress:
+                    func = self.on_progress()
+                    if func:
+                        func(self, data[0], data[1])
+
+            elif result == 'killed':
+                if self._debug:
+                    Logger.debug('UrlRequest: Cancelled by user')
+                if self.on_cancel:
+                    func = self.on_cancel()
+                    if func:
+                        func(self)
+
+            else:
+                assert(0)
+
+    @property
+    def is_finished(self):
+        '''Return True if the request has finished, whether it's a
+        success or a failure.
+        '''
+        return self._is_finished
+
+    @property
+    def result(self):
+        '''Return the result of the request.
+        This value is not determined until the request is finished.
+        '''
+        return self._result
+
+    @property
+    def resp_headers(self):
+        '''If the request has been completed, return a dictionary containing
+        the headers of the response. Otherwise, it will return None.
+        '''
+        return self._resp_headers
+
+    @property
+    def resp_status(self):
+        '''Return the status code of the response if the request is complete,
+        otherwise return None.
+        '''
+        return self._resp_status
+
+    @property
+    def error(self):
+        '''Return the error of the request.
+        This value is not determined until the request is completed.
+        '''
+        return self._error
+
+    @property
+    def chunk_size(self):
+        '''Return the size of a chunk, used only in "progress" mode (when
+        on_progress callback is set.)
+        '''
+        return self._chunk_size
+
+    def wait(self, delay=0.5):
+        '''Wait for the request to finish (until :attr:`resp_status` is not
+        None)
+
+        .. note::
+            This method is intended to be used in the main thread, and the
+            callback will be dispatched from the same thread
+            from which you're calling.
+
+        .. versionadded:: 1.1.0
+        '''
+        while self.resp_status is None:
+            self._dispatch_result(delay)
+            sleep(delay)
+
+    def cancel(self):
+        '''Cancel the current request. It will be aborted, and the result
+        will not be dispatched. Once cancelled, the callback on_cancel will
+        be called.
+
+        .. versionadded:: 1.11.0
+        '''
+        self._cancel_event.set()
+
+
+if __name__ == '__main__':
+
+    from pprint import pprint
+
+    def on_success(req, result):
+        pprint('Got the result:')
+        pprint(result)
+
+    def on_error(req, error):
+        pprint('Got an error:')
+        pprint(error)
+
+    Clock.start_clock()
+    req = UrlRequest('https://en.wikipedia.org/w/api.php?format'
+        '=json&action=query&titles=Kivy&prop=revisions&rvprop=content',
+        on_success, on_error)
+    while not req.is_finished:
+        sleep(1)
+        Clock.tick()
+    Clock.stop_clock()
+
+    print('result =', req.result)
+    print('error =', req.error)
diff --git a/kivy/parser.py b/kivy/parser.py
new file mode 100644
index 0000000..55892d1
--- /dev/null
+++ b/kivy/parser.py
@@ -0,0 +1,154 @@
+'''
+Parser utilities
+================
+
+Helper functions used for CSS parsing.
+'''
+
+__all__ = ('parse_color', 'parse_int', 'parse_float',
+           'parse_string', 'parse_bool', 'parse_int2',
+           'parse_float4', 'parse_filename')
+
+import re
+from kivy.logger import Logger
+from kivy.resources import resource_find
+
+
+class ColorException(Exception):
+    pass
+
+
+def parse_filename(filename):
+    '''Parse a filename and search for it using `resource_find()`.
+    If found, the resource path is returned, otherwise return the unmodified
+    filename (as specified by the caller).'''
+    filename = parse_string(filename)
+    result = resource_find(filename)
+    if result is None:
+        Logger.error('Resource: unable to find <%s>' % filename)
+    return result or filename
+
+
+def color_error(text):
+    # show warning and return a sane value
+    Logger.warning(text)
+    return (0, 0, 0, 1)
+
+
+def parse_color(text):
+    '''Parse a string to a kivy color. Supported formats:
+
+        * rgb(r, g, b)
+        * rgba(r, g, b, a)
+        * rgb
+        * rgba
+        * rrggbb
+        * rrggbbaa
+
+    For hexadecimal values, you case also use:
+
+        * #rgb
+        * #rgba
+        * #rrggbb
+        * #rrggbbaa
+    '''
+    value = [1, 1, 1, 1]
+    if text.startswith('rgb'):
+        res = re.match(r'rgba?\((.*)\)', text)
+        if res:
+            try:
+                # default r/g/b values to 1 if greater than 255 else x/255
+                value = [1 if int(x) > 255. else (int(x) / 255.)
+                         for x in re.split(', ?', res.groups()[0])]
+                if len(value) < 3:
+                    # in case of invalid input like rgb()/rgb(r)/rgb(r, g)
+                    raise ValueError
+            except ValueError:
+                return color_error('ColorParser: Invalid color for %r' % text)
+            except AttributeError:
+                return color_error('ColorParser: Invalid color for %r' % text)
+        else:
+            return color_error('ColorParser: Invalid color for %r' % text)
+        if len(value) == 3:
+            value.append(1.)
+    elif len(text):
+        res = text
+        if text[0] == '#':
+            res = text[1:]
+        lres = len(res)
+        if lres == 3 or lres == 4:
+            res = ''.join([x + x for x in res])
+        elif lres != 6 and lres != 8:
+            # raise ColorException('Invalid color format for %r' % text)
+            return color_error(
+                'ColorParser: Invalid color format for %r' % text)
+        try:
+            value = [int(res[i:i + 2], 16) / 255.
+                     for i in range(0, len(res), 2)]
+        except ValueError:
+            return color_error('ColorParser: Invalid color for %r' % text)
+        if lres == 6 or lres == 3:
+            value.append(1.)
+    return value
+
+
+def parse_bool(text):
+    '''Parse a string to a boolean, ignoring case. "true"/"1" is True,
+    "false"/"0" is False. Anything else throws an exception.'''
+    if text.lower() in ('true', '1'):
+        return True
+    elif text.lower() in ('false', '0'):
+        return False
+    raise Exception('Invalid boolean: %s' % text)
+
+
+def parse_string(text):
+    '''Parse a string to a string (removing single and double quotes).'''
+    if len(text) >= 2 and text[0] in ('"', "'") and text[-1] in ('"', "'"):
+        text = text[1:-1]
+    return text.strip()
+
+
+def parse_int2(text):
+    '''Parse a string to a list of exactly 2 integers.
+
+        >>> print(parse_int2("12 54"))
+        12, 54
+
+    '''
+    texts = [x for x in text.split(' ') if x.strip() != '']
+    value = list(map(parse_int, texts))
+    if len(value) < 1:
+        raise Exception('Invalid int2 format: %s' % text)
+    elif len(value) == 1:
+        return [value[0], value[0]]
+    elif len(value) > 2:
+        raise Exception('Too many values in %s: %s' % (text, str(value)))
+    return value
+
+
+def parse_float4(text):
+    '''Parse a string to a list of exactly 4 floats.
+
+        >>> parse_float4('54 87. 35 0')
+        54, 87., 35, 0
+
+    '''
+    texts = [x for x in text.split(' ') if x.strip() != '']
+    value = list(map(parse_float, texts))
+    if len(value) < 1:
+        raise Exception('Invalid float4 format: %s' % text)
+    elif len(value) == 1:
+        return [value[0] for x in range(4)]
+    elif len(value) == 2:
+        return [value[0], value[1], value[0], value[1]]
+    elif len(value) == 3:
+        # ambiguous case!
+        return [value[0], value[1], value[0], value[2]]
+    elif len(value) > 4:
+        raise Exception('Too many values in %s' % text)
+    return value
+
+
+parse_int = int
+parse_float = float
diff --git a/kivy/properties.cpython-310-x86_64-linux-gnu.so b/kivy/properties.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..ffe112f
Binary files /dev/null and b/kivy/properties.cpython-310-x86_64-linux-gnu.so differ
diff --git a/kivy/properties.pxd b/kivy/properties.pxd
new file mode 100644
index 0000000..870ee53
--- /dev/null
+++ b/kivy/properties.pxd
@@ -0,0 +1,153 @@
+from kivy._event cimport EventDispatcher, EventObservers, BoundCallback, \
+    cache_properties_per_cls
+from kivy._metrics cimport dpi2px, pixel_scale_observers
+
+cdef class PropertyStorage:
+    cdef object value
+    cdef EventObservers observers
+    cdef Property property_obj
+
+
+cdef class Property:
+    cdef str _name
+    cdef int allownone
+    cdef int force_dispatch
+    cdef object comparator
+    cdef object errorvalue
+    cdef object errorhandler
+    cdef int errorvalue_set
+    cdef public object defaultvalue
+    cdef int deprecated
+    cdef init_storage(self, EventDispatcher obj, PropertyStorage storage)
+    cdef PropertyStorage create_property_storage(self)
+    cdef inline PropertyStorage get_property_storage(self, EventDispatcher obj)
+    cpdef set_name(self, EventDispatcher obj, str name)
+    cpdef PropertyStorage link_eagerly(self, EventDispatcher obj)
+    cpdef PropertyStorage link(self, EventDispatcher obj, str name)
+    cpdef link_deps(self, EventDispatcher obj, str name)
+    cpdef bind(self, EventDispatcher obj, observer)
+    cpdef fbind(self, EventDispatcher obj, observer, int ref, tuple largs=*, dict kwargs=*)
+    cpdef unbind(self, EventDispatcher obj, observer, int stop_on_first=*)
+    cpdef funbind(self, EventDispatcher obj, observer, tuple largs=*, dict kwargs=*)
+    cpdef unbind_uid(self, EventDispatcher obj, object uid)
+    cdef compare_value(self, a, b)
+    cpdef set(self, EventDispatcher obj, value)
+    cpdef get(self, EventDispatcher obj)
+    cdef check(self, EventDispatcher obj, x, PropertyStorage property_storage)
+    cdef convert(self, EventDispatcher obj, x, PropertyStorage property_storage)
+    cpdef dispatch(self, EventDispatcher obj)
+    cdef _dispatch(self, EventDispatcher obj, PropertyStorage ps)
+
+
+cdef class NumericPropertyStorage(PropertyStorage):
+    cdef object numeric_fmt
+    cdef object original_num
+
+
+cdef class NumericProperty(Property):
+    cdef float parse_str(
+            self, EventDispatcher obj, value, NumericPropertyStorage ps) except *
+    cdef float parse_list(
+            self, EventDispatcher obj, value, ext, NumericPropertyStorage ps) except *
+
+cdef class StringProperty(Property):
+    pass
+
+cdef class ListProperty(Property):
+    pass
+
+cdef class DictProperty(Property):
+    cdef public int rebind
+
+cdef class ObjectProperty(Property):
+    cdef object baseclass
+    cdef public int rebind
+
+cdef class BooleanProperty(Property):
+    pass
+
+
+cdef class BoundedNumericPropertyStorage(PropertyStorage):
+    cdef long bnum_min
+    cdef long bnum_max
+    cdef float bnum_f_min
+    cdef float bnum_f_max
+    cdef int bnum_use_min
+    cdef int bnum_use_max
+
+
+cdef class BoundedNumericProperty(Property):
+    cdef int use_min
+    cdef int use_max
+    cdef long min
+    cdef long max
+    cdef float f_min
+    cdef float f_max
+
+
+cdef class OptionPropertyStorage(PropertyStorage):
+    cdef list options
+
+
+cdef class OptionProperty(Property):
+    cdef list options
+
+
+cdef class ReferenceListPropertyStorage(PropertyStorage):
+    cdef tuple properties
+    cdef int stop_event
+
+
+cdef class ReferenceListProperty(Property):
+    cdef list properties
+    cpdef trigger_change(self, EventDispatcher obj, value)
+    cpdef setitem(self, EventDispatcher obj, key, value)
+
+
+cdef class AliasPropertyStorage(PropertyStorage):
+    cdef object getter
+    cdef object setter
+    cdef int alias_initial
+
+
+cdef class AliasProperty(Property):
+    cdef object getter
+    cdef object setter
+    cdef int watch_before_use
+    cdef list bind_objects
+    cdef int use_cache
+    cdef public int rebind
+    cpdef trigger_change(self, EventDispatcher obj, value)
+
+
+cdef class VariableListPropertyStorage(PropertyStorage):
+    cdef object original_num
+    cdef int uses_scaling
+
+
+cdef class VariableListProperty(Property):
+    cdef public int length
+    cdef _convert_numeric(self, EventDispatcher obj, x, VariableListPropertyStorage ps)
+    cdef float parse_str(
+            self, EventDispatcher obj, value, VariableListPropertyStorage ps
+    ) except *
+    cdef float parse_list(
+            self, EventDispatcher obj, value, ext, VariableListPropertyStorage ps
+    ) except *
+
+
+cdef class ConfigParserProperty(Property):
+    cdef object config
+    cdef object section
+    cdef object key
+    cdef object val_type
+    cdef object verify
+    cdef object obj
+    cdef object last_value  # last string config value
+    cdef object config_name
+    cpdef _edit_setting(self, section, key, value)
+    cdef inline object _parse_str(self, object value)
+
+cdef class ColorProperty(Property):
+    cdef list parse_str(self, EventDispatcher obj, value)
+    cdef object parse_list(self, EventDispatcher obj, value)
diff --git a/kivy/resources.py b/kivy/resources.py
new file mode 100644
index 0000000..f3edce9
--- /dev/null
+++ b/kivy/resources.py
@@ -0,0 +1,102 @@
+'''
+Resources management
+====================
+
+Resource management can be a pain if you have multiple paths and projects.
+Kivy offers 2 functions for searching for specific resources across a list
+of paths.
+
+Resource lookup
+---------------
+
+When Kivy looks for a resource e.g. an image or a kv file, it searches through
+a predetermined set of folders. You can modify this folder list using the
+:meth:`resource_add_path` and :meth:`resource_remove_path` functions.
+
+Customizing Kivy
+----------------
+
+These functions can also be helpful if you want to replace standard Kivy
+resources with your own. For example, if you wish to customize or re-style
+Kivy, you can force your *style.kv* or *data/defaulttheme-0.png* files to be
+used in preference to the defaults simply by adding the path to your preferred
+alternatives via the :meth:`resource_add_path` method.
+
+As almost all Kivy resources are looked up using the :meth:`resource_find`, so
+you can use this approach to add fonts and keyboard layouts and to replace
+images and icons.
+
+'''
+
+__all__ = ('resource_find', 'resource_add_path', 'resource_remove_path')
+
+from os.path import join, dirname, exists, abspath
+from kivy import kivy_data_dir
+from kivy.cache import Cache
+from kivy.utils import platform
+from kivy.logger import Logger
+import sys
+import os
+import kivy
+
+resource_paths = ['.', dirname(sys.argv[0])]
+if platform == 'ios':
+    resource_paths += [join(dirname(sys.argv[0]), 'YourApp')]
+resource_paths += [dirname(kivy.__file__), join(kivy_data_dir, '..')]
+
+Cache.register('kv.resourcefind', timeout=60)
+
+
+def resource_find(filename, use_cache=("KIVY_DOC_INCLUDE" not in os.environ)):
+    '''Search for a resource in the list of paths.
+    Use resource_add_path to add a custom path to the search.
+    By default, results are cached for 60 seconds.
+    This can be disabled using use_cache=False.
+
+    .. versionchanged:: 2.1.0
+        `use_cache` parameter added and made True by default.
+    '''
+    if not filename:
+        return
+    found_filename = None
+    if use_cache:
+        found_filename = Cache.get('kv.resourcefind', filename)
+        if found_filename:
+            return found_filename
+    if filename[:8] == 'atlas://':
+        found_filename = filename
+    else:
+        abspath_filename = abspath(filename)
+        if exists(abspath_filename):
+            found_filename = abspath(filename)
+        else:
+            for path in reversed(resource_paths):
+                abspath_filename = abspath(join(path, filename))
+                if exists(abspath_filename):
+                    found_filename = abspath_filename
+                    break
+        if not found_filename and filename.startswith("data:"):
+            found_filename = filename
+    if use_cache and found_filename:
+        Cache.append('kv.resourcefind', filename, found_filename)
+    return found_filename
+
+
+def resource_add_path(path):
+    '''Add a custom path to search in.
+    '''
+    if path in resource_paths:
+        return
+    Logger.debug('Resource: add <%s> in path list' % path)
+    resource_paths.append(path)
+
+
+def resource_remove_path(path):
+    '''Remove a search path.
+
+    .. versionadded:: 1.0.8
+    '''
+    if path not in resource_paths:
+        return
+    Logger.debug('Resource: remove <%s> from path list' % path)
+    resource_paths.remove(path)
diff --git a/kivy/setupconfig.py b/kivy/setupconfig.py
new file mode 100644
index 0000000..5c2c6aa
--- /dev/null
+++ b/kivy/setupconfig.py
@@ -0,0 +1,23 @@
+# Autogenerated file for Kivy configuration
+PY3 = 1
+CYTHON_MIN = '0.24'
+CYTHON_MAX = '0.29.28'
+CYTHON_BAD = '0.27, 0.27.2'
+USE_RPI = 0
+USE_EGL = 0
+USE_OPENGL_ES2 = 0
+USE_OPENGL_MOCK = 0
+USE_SDL2 = 1
+USE_PANGOFT2 = 0
+USE_IOS = 0
+USE_ANDROID = 0
+USE_MESAGL = 0
+USE_X11 = 1
+USE_WAYLAND = 0
+USE_GSTREAMER = 0
+USE_AVFOUNDATION = 0
+USE_OSX_FRAMEWORKS = 0
+DEBUG_GL = 0
+KIVY_SDL_GL_ALPHA_SIZE = 8
+DEBUG = False
+PLATFORM = "linux"
diff --git a/kivy/storage/__init__.py b/kivy/storage/__init__.py
new file mode 100644
index 0000000..65b135d
--- /dev/null
+++ b/kivy/storage/__init__.py
@@ -0,0 +1,405 @@
+'''
+Storage
+=======
+
+.. versionadded:: 1.7.0
+
+.. warning::
+
+    This module is still experimental, and the API is subject to change in a
+    future version.
+
+Usage
+-----
+
+The idea behind the Storage module is to be able to load/store any number of
+key-value pairs via an indexed key. The default model is abstract so you
+cannot use it directly. We provide some implementations such as:
+
+- :class:`kivy.storage.dictstore.DictStore`: use a python dict as a store
+- :class:`kivy.storage.jsonstore.JsonStore`: use a
+  `JSON <https://en.wikipedia.org/wiki/JSON>`_ file as a store
+- :class:`kivy.storage.redisstore.RedisStore`: use a `Redis <http://redis.io>`_
+  database with `redis-py <https://github.com/andymccurdy/redis-py>`_
+
+
+Examples
+--------
+
+For example, let's use a JsonStore::
+
+    from kivy.storage.jsonstore import JsonStore
+
+    store = JsonStore('hello.json')
+
+    # put some values
+    store.put('tito', name='Mathieu', org='kivy')
+    store.put('tshirtman', name='Gabriel', age=27)
+
+    # using the same index key erases all previously added key-value pairs
+    store.put('tito', name='Mathieu', age=30)
+
+    # get a value using a index key and key
+    print('tito is', store.get('tito')['age'])
+
+    # or guess the key/entry for a part of the key
+    for item in store.find(name='Gabriel'):
+        print('tshirtmans index key is', item[0])
+        print('his key value pairs are', str(item[1]))
+
+Because the data is persistent, you can check later to see if the key exists::
+
+    from kivy.storage.jsonstore import JsonStore
+
+    store = JsonStore('hello.json')
+    if store.exists('tito'):
+        print('tite exists:', store.get('tito'))
+        store.delete('tito')
+
+
+Synchronous / Asynchronous API
+------------------------------
+
+All the standard methods (:meth:`~AbstractStore.get`,
+:meth:`~AbstractStore.put` , :meth:`~AbstractStore.exists`,
+:meth:`~AbstractStore.delete`, :meth:`~AbstractStore.find`) have an
+asynchronous version.
+
+For example, the *get* method has a `callback` parameter. If set, the
+`callback` will be used to return the result to the user when available:
+the request will be asynchronous. If the `callback` is None, then the
+request will be synchronous and the result will be returned directly.
+
+
+Without callback (Synchronous API)::
+
+    entry = mystore.get('tito')
+    print('tito =', entry)
+
+With callback (Asynchronous API)::
+
+    def my_callback(store, key, result):
+        print('the key', key, 'has a value of', result)
+    mystore.get('plop', callback=my_callback)
+
+
+The callback signature (for almost all methods) is::
+
+    def callback(store, key, result):
+        """
+        store: the `Store` instance currently used.
+        key: the key sought for.
+        result: the result of the lookup for the key.
+        """
+
+
+Synchronous container type
+--------------------------
+
+The storage API emulates the container type for the synchronous API::
+
+    store = JsonStore('hello.json')
+
+    # original: store.get('tito')
+    store['tito']
+
+    # original: store.put('tito', name='Mathieu')
+    store['tito'] = {'name': 'Mathieu'}
+
+    # original: store.delete('tito')
+    del store['tito']
+
+    # original: store.count()
+    len(store)
+
+    # original: store.exists('tito')
+    'tito' in store
+
+    # original: for key in store.keys()
+    for key in store:
+        pass
+
+'''
+
+from kivy.clock import Clock
+from kivy.event import EventDispatcher
+
+
+class AbstractStore(EventDispatcher):
+    '''Abstract class used to implement a Store
+    '''
+
+    def __init__(self, **kwargs):
+        super(AbstractStore, self).__init__(**kwargs)
+        self.store_load()
+
+    def exists(self, key):
+        '''Check if a key exists in the store.
+        '''
+        return self.store_exists(key)
+
+    def async_exists(self, callback, key):
+        '''Asynchronous version of :meth:`exists`.
+
+        :Callback arguments:
+            `store`: :class:`AbstractStore` instance
+                Store instance
+            `key`: string
+                Name of the key to search for
+            `result`: boo
+                Result of the query, None if any error
+        '''
+        self._schedule(self.store_exists_async,
+                       key=key, callback=callback)
+
+    def get(self, key):
+        '''Get the key-value pairs stored at `key`. If the key is not found, a
+        `KeyError` exception will be thrown.
+        '''
+        return self.store_get(key)
+
+    def async_get(self, callback, key):
+        '''Asynchronous version of :meth:`get`.
+
+        :Callback arguments:
+            `store`: :class:`AbstractStore` instance
+                Store instance
+            `key`: string
+                Name of the key to search for
+            `result`: dict
+                Result of the query, None if any error
+        '''
+        self._schedule(self.store_get_async, key=key, callback=callback)
+
+    def put(self, key, **values):
+        '''Put new key-value pairs (given in *values*) into the storage. Any
+        existing key-value pairs will be removed.
+        '''
+        need_sync = self.store_put(key, values)
+        if need_sync:
+            self.store_sync()
+        return need_sync
+
+    def async_put(self, callback, key, **values):
+        '''Asynchronous version of :meth:`put`.
+
+        :Callback arguments:
+            `store`: :class:`AbstractStore` instance
+                Store instance
+            `key`: string
+                Name of the key to search for
+            `result`: bool
+                Indicate True if the storage has been updated, or False if
+                nothing has been done (no changes). None if any error.
+        '''
+        self._schedule(self.store_put_async,
+                       key=key, value=values, callback=callback)
+
+    def delete(self, key):
+        '''Delete a key from the storage. If the key is not found, a `KeyError`
+        exception will be thrown.'''
+        need_sync = self.store_delete(key)
+        if need_sync:
+            self.store_sync()
+        return need_sync
+
+    def async_delete(self, callback, key):
+        '''Asynchronous version of :meth:`delete`.
+
+        :Callback arguments:
+            `store`: :class:`AbstractStore` instance
+                Store instance
+            `key`: string
+                Name of the key to search for
+            `result`: bool
+                Indicate True if the storage has been updated, or False if
+                nothing has been done (no changes). None if any error.
+        '''
+        self._schedule(self.store_delete_async, key=key,
+                       callback=callback)
+
+    def find(self, **filters):
+        '''Return all the entries matching the filters. The entries are
+        returned through a generator as a list of (key, entry) pairs
+        where *entry* is a dict of key-value pairs ::
+
+            for key, entry in store.find(name='Mathieu'):
+                print('key:', key, ', entry:', entry)
+
+        Because it's a generator, you cannot directly use it as a list. You can
+        do::
+
+            # get all the (key, entry) availables
+            entries = list(store.find(name='Mathieu'))
+            # get only the entry from (key, entry)
+            entries = list((x[1] for x in store.find(name='Mathieu')))
+        '''
+        return self.store_find(filters)
+
+    def async_find(self, callback, **filters):
+        '''Asynchronous version of :meth:`find`.
+
+        The callback will be called for each entry in the result.
+
+        :Callback arguments:
+            `store`: :class:`AbstractStore` instance
+                Store instance
+            `key`: string
+                Name of the key to search for, or None if we reach the end of
+                the results
+            `result`: bool
+                Indicate True if the storage has been updated, or False if
+                nothing has been done (no changes). None if any error.
+        '''
+        self._schedule(self.store_find_async,
+                       callback=callback, filters=filters)
+
+    def keys(self):
+        '''Return a list of all the keys in the storage.
+        '''
+        return self.store_keys()
+
+    def async_keys(self, callback):
+        '''Asynchronously return all the keys in the storage.
+        '''
+        self._schedule(self.store_keys_async, callback=callback)
+
+    def count(self):
+        '''Return the number of entries in the storage.
+        '''
+        return self.store_count()
+
+    def async_count(self, callback):
+        '''Asynchronously return the number of entries in the storage.
+        '''
+        self._schedule(self.store_count_async, callback=callback)
+
+    def clear(self):
+        '''Wipe the whole storage.
+        '''
+        return self.store_clear()
+
+    def async_clear(self, callback):
+        '''Asynchronous version of :meth:`clear`.
+        '''
+        self._schedule(self.store_clear_async, callback=callback)
+
+    #
+    # Operators
+    #
+
+    def __setitem__(self, key, values):
+        if not isinstance(values, dict):
+            raise Exception('Only dict are accepted for the store[key] = dict')
+        self.put(key, **values)
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def __delitem__(self, key):
+        return self.keys()
+
+    def __contains__(self, key):
+        return self.exists(key)
+
+    def __len__(self):
+        return self.count()
+
+    def __iter__(self):
+        for key in self.keys():
+            yield key
+
+    #
+    # Used for implementation
+    #
+
+    def store_load(self):
+        pass
+
+    def store_sync(self):
+        pass
+
+    def store_get(self, key):
+        raise NotImplementedError
+
+    def store_put(self, key, value):
+        raise NotImplementedError
+
+    def store_exists(self, key):
+        raise NotImplementedError
+
+    def store_delete(self, key):
+        raise NotImplementedError
+
+    def store_find(self, filters):
+        return []
+
+    def store_keys(self):
+        return []
+
+    def store_count(self):
+        return len(self.store_keys())
+
+    def store_clear(self):
+        for key in self.store_keys():
+            self.store_delete(key)
+        self.store_sync()
+
+    def store_get_async(self, key, callback):
+        try:
+            value = self.store_get(key)
+            callback(self, key, value)
+        except KeyError:
+            callback(self, key, None)
+
+    def store_put_async(self, key, value, callback):
+        try:
+            value = self.put(key, **value)
+            callback(self, key, value)
+        except:
+            callback(self, key, None)
+
+    def store_exists_async(self, key, callback):
+        try:
+            value = self.store_exists(key)
+            callback(self, key, value)
+        except:
+            callback(self, key, None)
+
+    def store_delete_async(self, key, callback):
+        try:
+            value = self.delete(key)
+            callback(self, key, value)
+        except:
+            callback(self, key, None)
+
+    def store_find_async(self, filters, callback):
+        for key, entry in self.store_find(filters):
+            callback(self, filters, key, entry)
+        callback(self, filters, None, None)
+
+    def store_count_async(self, callback):
+        try:
+            value = self.store_count()
+            callback(self, value)
+        except:
+            callback(self, 0)
+
+    def store_keys_async(self, callback):
+        try:
+            keys = self.store_keys()
+            callback(self, keys)
+        except:
+            callback(self, [])
+
+    def store_clear_async(self, callback):
+        self.store_clear()
+        callback(self)
+
+    #
+    # Privates
+    #
+
+    def _schedule(self, cb, **kwargs):
+        # XXX not entirely sure about the best value (0 or -1).
+        Clock.schedule_once(lambda dt: cb(**kwargs), 0)
diff --git a/kivy/storage/__pycache__/__init__.cpython-310.pyc b/kivy/storage/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..9d2d2bd
Binary files /dev/null and b/kivy/storage/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/storage/__pycache__/dictstore.cpython-310.pyc b/kivy/storage/__pycache__/dictstore.cpython-310.pyc
new file mode 100644
index 0000000..be70e25
Binary files /dev/null and b/kivy/storage/__pycache__/dictstore.cpython-310.pyc differ
diff --git a/kivy/storage/__pycache__/jsonstore.cpython-310.pyc b/kivy/storage/__pycache__/jsonstore.cpython-310.pyc
new file mode 100644
index 0000000..c2fbfc0
Binary files /dev/null and b/kivy/storage/__pycache__/jsonstore.cpython-310.pyc differ
diff --git a/kivy/storage/__pycache__/redisstore.cpython-310.pyc b/kivy/storage/__pycache__/redisstore.cpython-310.pyc
new file mode 100644
index 0000000..fd2e180
Binary files /dev/null and b/kivy/storage/__pycache__/redisstore.cpython-310.pyc differ
diff --git a/kivy/storage/dictstore.py b/kivy/storage/dictstore.py
new file mode 100644
index 0000000..204cbac
--- /dev/null
+++ b/kivy/storage/dictstore.py
@@ -0,0 +1,98 @@
+'''
+Dictionary store
+=================
+
+Use a Python dictionary as a store.
+'''
+
+__all__ = ('DictStore', )
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+import errno
+from os.path import exists, abspath, dirname
+from kivy.compat import iteritems
+from kivy.storage import AbstractStore
+
+
+class DictStore(AbstractStore):
+    '''Store implementation using a pickled `dict`.
+    See the :mod:`kivy.storage` module documentation for more information.
+    '''
+    def __init__(self, filename, data=None, **kwargs):
+        if isinstance(filename, dict):
+            # backward compatibility, first argument was a dict.
+            self.filename = None
+            self._data = filename
+        else:
+            self.filename = filename
+            self._data = data or {}
+        self._is_changed = True
+        super(DictStore, self).__init__(**kwargs)
+
+    def store_load(self):
+        if self.filename is None:
+            return
+        if not exists(self.filename):
+            folder = abspath(dirname(self.filename))
+            if not exists(folder):
+                not_found = IOError(
+                    "The folder '{}' doesn't exist!"
+                    "".format(folder)
+                )
+                not_found.errno = errno.ENOENT
+                raise not_found
+            return
+        with open(self.filename, 'rb') as fd:
+            data = fd.read()
+            if data:
+                self._data = pickle.loads(data)
+
+    def store_sync(self):
+        if self.filename is None:
+            return
+        if not self._is_changed:
+            return
+
+        with open(self.filename, 'wb') as fd:
+            pickle.dump(self._data, fd)
+
+        self._is_changed = False
+
+    def store_exists(self, key):
+        return key in self._data
+
+    def store_get(self, key):
+        return self._data[key]
+
+    def store_put(self, key, value):
+        self._data[key] = value
+        self._is_changed = True
+        return True
+
+    def store_delete(self, key):
+        del self._data[key]
+        self._is_changed = True
+        return True
+
+    def store_find(self, filters):
+        for key, values in iteritems(self._data):
+            found = True
+            for fkey, fvalue in iteritems(filters):
+                if fkey not in values:
+                    found = False
+                    break
+                if values[fkey] != fvalue:
+                    found = False
+                    break
+            if found:
+                yield key, values
+
+    def store_count(self):
+        return len(self._data)
+
+    def store_keys(self):
+        return list(self._data.keys())
diff --git a/kivy/storage/jsonstore.py b/kivy/storage/jsonstore.py
new file mode 100644
index 0000000..5c3fe7b
--- /dev/null
+++ b/kivy/storage/jsonstore.py
@@ -0,0 +1,92 @@
+'''
+JSON store
+==========
+
+A :mod:`Storage <kivy.storage>` module used to save/load key-value pairs from
+a json file.
+'''
+
+__all__ = ('JsonStore', )
+
+
+import errno
+from os.path import exists, abspath, dirname
+from kivy.compat import iteritems
+from kivy.storage import AbstractStore
+from json import loads, dump
+
+
+class JsonStore(AbstractStore):
+    '''Store implementation using a json file for storing the key-value pairs.
+    See the :mod:`kivy.storage` module documentation for more information.
+    '''
+    def __init__(self, filename, indent=None, sort_keys=False, **kwargs):
+        self.filename = filename
+        self.indent = indent
+        self.sort_keys = sort_keys
+        self._data = {}
+        self._is_changed = True
+        super(JsonStore, self).__init__(**kwargs)
+
+    def store_load(self):
+        if not exists(self.filename):
+            folder = abspath(dirname(self.filename))
+            if not exists(folder):
+                not_found = IOError(
+                    "The folder '{}' doesn't exist!"
+                    "".format(folder)
+                )
+                not_found.errno = errno.ENOENT
+                raise not_found
+            return
+        with open(self.filename) as fd:
+            data = fd.read()
+            if len(data) == 0:
+                return
+            self._data = loads(data)
+
+    def store_sync(self):
+        if not self._is_changed:
+            return
+        with open(self.filename, 'w') as fd:
+            dump(
+                self._data, fd,
+                indent=self.indent,
+                sort_keys=self.sort_keys
+            )
+        self._is_changed = False
+
+    def store_exists(self, key):
+        return key in self._data
+
+    def store_get(self, key):
+        return self._data[key]
+
+    def store_put(self, key, value):
+        self._data[key] = value
+        self._is_changed = True
+        return True
+
+    def store_delete(self, key):
+        del self._data[key]
+        self._is_changed = True
+        return True
+
+    def store_find(self, filters):
+        for key, values in iteritems(self._data):
+            found = True
+            for fkey, fvalue in iteritems(filters):
+                if fkey not in values:
+                    found = False
+                    break
+                if values[fkey] != fvalue:
+                    found = False
+                    break
+            if found:
+                yield key, values
+
+    def store_count(self):
+        return len(self._data)
+
+    def store_keys(self):
+        return list(self._data.keys())
diff --git a/kivy/storage/redisstore.py b/kivy/storage/redisstore.py
new file mode 100644
index 0000000..4e36491
--- /dev/null
+++ b/kivy/storage/redisstore.py
@@ -0,0 +1,103 @@
+'''
+Redis Store
+===========
+
+Store implementation using Redis. You must have redis-py installed.
+
+Usage example::
+
+    from kivy.storage.redisstore import RedisStore
+
+    params = dict(host='localhost', port=6379, db=14)
+    store = RedisStore(params)
+
+All the key-value pairs will be stored with a prefix 'store' by default.
+You can instantiate the storage with another prefix like this::
+
+
+    from kivy.storage.redisstore import RedisStore
+
+    params = dict(host='localhost', port=6379, db=14)
+    store = RedisStore(params, prefix='mystore2')
+
+The params dictionary will be passed to the redis.StrictRedis class.
+
+See `redis-py <https://github.com/andymccurdy/redis-py>`_.
+'''
+
+__all__ = ('RedisStore', )
+
+import os
+from json import loads, dumps
+from kivy.compat import iteritems
+from kivy.properties import StringProperty
+from kivy.storage import AbstractStore
+
+# don't import redis during the documentation generation
+if 'KIVY_DOC' not in os.environ:
+    import redis
+
+
+class RedisStore(AbstractStore):
+    '''Store implementation using a Redis database.
+    See the :mod:`kivy.storage` module documentation for more information.
+    '''
+
+    prefix = StringProperty('store')
+
+    def __init__(self, redis_params, **kwargs):
+        self.redis_params = redis_params
+        self.r = None
+        super(RedisStore, self).__init__(**kwargs)
+
+    def store_load(self):
+        self.r = redis.StrictRedis(**self.redis_params)
+
+    def store_sync(self):
+        pass
+
+    def store_exists(self, key):
+        key = self.prefix + '.d.' + key
+        value = self.r.exists(key)
+        return value
+
+    def store_get(self, key):
+        key = self.prefix + '.d.' + key
+        if not self.r.exists(key):
+            raise KeyError(key)
+        result = self.r.hgetall(key)
+        for k in result.keys():
+            result[k] = loads(result[k])
+        return result
+
+    def store_put(self, key, values):
+        key = self.prefix + '.d.' + key
+        pipe = self.r.pipeline()
+        pipe.delete(key)
+        for k, v in iteritems(values):
+            pipe.hset(key, k, dumps(v))
+        pipe.execute()
+        return True
+
+    def store_delete(self, key):
+        key = self.prefix + '.d.' + key
+        if not self.r.exists(key):
+            raise KeyError(key)
+        return self.r.delete(key)
+
+    def store_keys(self):
+        z = len(self.prefix + '.d.')
+        return [x[z:] for x in self.r.keys(self.prefix + '.d.*')]
+
+    def store_find(self, filters):
+        fkeys = filters.keys()
+        fvalues = filters.values()
+        for key in self.store_keys():
+            skey = self.prefix + '.d.' + key
+            svalues = self.r.hmget(skey, fkeys)
+            if None in svalues:
+                continue
+            svalues = [loads(x) for x in svalues]
+            if fvalues != svalues:
+                continue
+            yield key, self.r.hgetall(skey)
diff --git a/kivy/support.py b/kivy/support.py
new file mode 100644
index 0000000..36e0677
--- /dev/null
+++ b/kivy/support.py
@@ -0,0 +1,267 @@
+'''
+Support
+=======
+
+Activate other frameworks/toolkits inside the kivy event loop.
+
+'''
+
+__all__ = ('install_gobject_iteration', 'install_twisted_reactor',
+           'uninstall_twisted_reactor', 'install_android')
+
+
+def install_gobject_iteration():
+    '''Import and install gobject context iteration inside our event loop.
+    This is used as soon as gobject is used (like gstreamer).
+    '''
+
+    from kivy.clock import Clock
+
+    try:
+        from gi.repository import GObject as gobject
+    except ImportError:
+        import gobject
+
+    if hasattr(gobject, '_gobject_already_installed'):
+        # already installed, don't do it twice.
+        return
+
+    gobject._gobject_already_installed = True
+
+    # get gobject mainloop / context
+    loop = gobject.MainLoop()
+    gobject.threads_init()
+    context = loop.get_context()
+
+    # schedule the iteration each frame
+    def _gobject_iteration(*largs):
+        # XXX we need to loop over context here, otherwise, we might have a lag
+        loop = 0
+        while context.pending() and loop < 10:
+            context.iteration(False)
+            loop += 1
+    Clock.schedule_interval(_gobject_iteration, 0)
+
+
+# -----------------------------------------------------------------------------
+# Android support
+# -----------------------------------------------------------------------------
+
+g_android_redraw_count = 0
+_redraw_event = None
+
+
+def _android_ask_redraw(*largs):
+    # after wakeup, we need to redraw more than once, otherwise we get a
+    # black screen
+    global g_android_redraw_count
+    from kivy.core.window import Window
+    Window.canvas.ask_update()
+    g_android_redraw_count -= 1
+    if g_android_redraw_count < 0:
+        return False
+
+
+def install_android():
+    '''Install hooks for the android platform.
+
+    * Automatically sleep when the device is paused.
+    * Automatically kill the application when the return key is pressed.
+    '''
+    try:
+        import android
+    except ImportError:
+        print('Android lib is missing, cannot install android hooks')
+        return
+
+    from kivy.clock import Clock
+    from kivy.logger import Logger
+    import pygame
+
+    Logger.info('Support: Android install hooks')
+
+    # Init the library
+    android.init()
+    android.map_key(android.KEYCODE_MENU, pygame.K_MENU)
+    android.map_key(android.KEYCODE_BACK, pygame.K_ESCAPE)
+
+    # Check if android should be paused or not.
+    # If pause is requested, just leave the app.
+    def android_check_pause(*largs):
+        # do nothing until android asks for it.
+        if not android.check_pause():
+            return
+
+        from kivy.app import App
+        from kivy.base import stopTouchApp
+        from kivy.logger import Logger
+        from kivy.core.window import Window
+        global g_android_redraw_count, _redraw_event
+
+        # try to get the current running application
+        Logger.info('Android: Must go into sleep mode, check the app')
+        app = App.get_running_app()
+
+        # no running application, stop our loop.
+        if app is None:
+            Logger.info('Android: No app running, stop everything.')
+            stopTouchApp()
+            return
+
+        # try to go to pause mode
+        if app.dispatch('on_pause'):
+            Logger.info('Android: App paused, now wait for resume.')
+
+            # app goes in pause mode, wait.
+            android.wait_for_resume()
+
+            # is it a stop or resume ?
+            if android.check_stop():
+                # app must stop
+                Logger.info('Android: Android wants to close our app.')
+                stopTouchApp()
+            else:
+                # app resuming now !
+                Logger.info('Android: Android has resumed, resume the app.')
+                app.dispatch('on_resume')
+                Window.canvas.ask_update()
+                g_android_redraw_count = 25  # 5 frames/seconds for 5 seconds
+                if _redraw_event is None:
+                    _redraw_event = Clock.schedule_interval(
+                        _android_ask_redraw, 1 / 5)
+                else:
+                    _redraw_event.cancel()
+                    _redraw_event()
+                Logger.info('Android: App resume completed.')
+
+        # app doesn't support pause mode, just stop it.
+        else:
+            Logger.info('Android: App doesn\'t support pause mode, stop.')
+            stopTouchApp()
+
+    Clock.schedule_interval(android_check_pause, 0)
+
+
+_twisted_reactor_stopper = None
+_twisted_reactor_work = None
+
+
+def install_twisted_reactor(**kwargs):
+    '''Installs a threaded twisted reactor, which will schedule one
+    reactor iteration before the next frame only when twisted needs
+    to do some work.
+
+    Any arguments or keyword arguments passed to this function will be
+    passed on the the threadedselect reactors interleave function. These
+    are the arguments one would usually pass to twisted's reactor.startRunning.
+
+    Unlike the default twisted reactor, the installed reactor will not handle
+    any signals unless you set the 'installSignalHandlers' keyword argument
+    to 1 explicitly. This is done to allow kivy to handle the signals as
+    usual unless you specifically want the twisted reactor to handle the
+    signals (e.g. SIGINT).
+
+    .. note::
+        Twisted is not included in iOS build by default. To use it on iOS,
+        put the twisted distribution (and zope.interface dependency) in your
+        application directory.
+    '''
+
+    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)
+
+
+def uninstall_twisted_reactor():
+    '''Uninstalls the Kivy's threaded Twisted Reactor. No more Twisted
+    tasks will run after this got called. Use this to clean the
+    `twisted.internet.reactor` .
+
+    .. versionadded:: 1.9.0
+    '''
+
+    import twisted
+
+    # prevent uninstalling more than once
+    if not hasattr(twisted, '_kivy_twisted_reactor_installed'):
+        return
+
+    from kivy.base import EventLoop
+
+    global _twisted_reactor_stopper
+    _twisted_reactor_stopper()
+    EventLoop.unbind(on_stop=_twisted_reactor_stopper)
+
+    del twisted._kivy_twisted_reactor_installed
diff --git a/kivy/tests/__init__.py b/kivy/tests/__init__.py
new file mode 100644
index 0000000..7944f54
--- /dev/null
+++ b/kivy/tests/__init__.py
@@ -0,0 +1,11 @@
+from kivy.tests.common import GraphicUnitTest, UnitTestTouch, UTMotionEvent, \
+    async_run
+try:
+    from kivy.tests.async_common import UnitKivyApp
+except SyntaxError:
+    # async app tests would be skipped due to async_run forcing it to skip so
+    # it's ok to be None as it won't be used anyway
+    UnitKivyApp = None
+
+__all__ = ('GraphicUnitTest', 'UnitTestTouch', 'UTMotionEvent', 'async_run',
+           'UnitKivyApp')
diff --git a/kivy/tests/__pycache__/__init__.cpython-310.pyc b/kivy/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..e6e0358
Binary files /dev/null and b/kivy/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/async_common.cpython-310.pyc b/kivy/tests/__pycache__/async_common.cpython-310.pyc
new file mode 100644
index 0000000..6e0fc94
Binary files /dev/null and b/kivy/tests/__pycache__/async_common.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/common.cpython-310.pyc b/kivy/tests/__pycache__/common.cpython-310.pyc
new file mode 100644
index 0000000..f2e8c33
Binary files /dev/null and b/kivy/tests/__pycache__/common.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/conftest.cpython-310.pyc b/kivy/tests/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000..e2f8028
Binary files /dev/null and b/kivy/tests/__pycache__/conftest.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/fixtures.cpython-310.pyc b/kivy/tests/__pycache__/fixtures.cpython-310.pyc
new file mode 100644
index 0000000..6375c30
Binary files /dev/null and b/kivy/tests/__pycache__/fixtures.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/perf_test_textinput.cpython-310.pyc b/kivy/tests/__pycache__/perf_test_textinput.cpython-310.pyc
new file mode 100644
index 0000000..b3fef09
Binary files /dev/null and b/kivy/tests/__pycache__/perf_test_textinput.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_animations.cpython-310.pyc b/kivy/tests/__pycache__/test_animations.cpython-310.pyc
new file mode 100644
index 0000000..14c3a1e
Binary files /dev/null and b/kivy/tests/__pycache__/test_animations.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_app.cpython-310.pyc b/kivy/tests/__pycache__/test_app.cpython-310.pyc
new file mode 100644
index 0000000..48d80a7
Binary files /dev/null and b/kivy/tests/__pycache__/test_app.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_audio.cpython-310.pyc b/kivy/tests/__pycache__/test_audio.cpython-310.pyc
new file mode 100644
index 0000000..c5a0414
Binary files /dev/null and b/kivy/tests/__pycache__/test_audio.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_benchmark.cpython-310.pyc b/kivy/tests/__pycache__/test_benchmark.cpython-310.pyc
new file mode 100644
index 0000000..d03905a
Binary files /dev/null and b/kivy/tests/__pycache__/test_benchmark.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_clipboard.cpython-310.pyc b/kivy/tests/__pycache__/test_clipboard.cpython-310.pyc
new file mode 100644
index 0000000..caeaa48
Binary files /dev/null and b/kivy/tests/__pycache__/test_clipboard.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_clock.cpython-310.pyc b/kivy/tests/__pycache__/test_clock.cpython-310.pyc
new file mode 100644
index 0000000..cf0d53a
Binary files /dev/null and b/kivy/tests/__pycache__/test_clock.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_compat.cpython-310.pyc b/kivy/tests/__pycache__/test_compat.cpython-310.pyc
new file mode 100644
index 0000000..7423b01
Binary files /dev/null and b/kivy/tests/__pycache__/test_compat.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_config.cpython-310.pyc b/kivy/tests/__pycache__/test_config.cpython-310.pyc
new file mode 100644
index 0000000..77a6e3b
Binary files /dev/null and b/kivy/tests/__pycache__/test_config.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_coverage.cpython-310.pyc b/kivy/tests/__pycache__/test_coverage.cpython-310.pyc
new file mode 100644
index 0000000..dc12c4b
Binary files /dev/null and b/kivy/tests/__pycache__/test_coverage.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_doc_gallery.cpython-310.pyc b/kivy/tests/__pycache__/test_doc_gallery.cpython-310.pyc
new file mode 100644
index 0000000..7bd02f0
Binary files /dev/null and b/kivy/tests/__pycache__/test_doc_gallery.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_environ_cli.cpython-310.pyc b/kivy/tests/__pycache__/test_environ_cli.cpython-310.pyc
new file mode 100644
index 0000000..7d5ac87
Binary files /dev/null and b/kivy/tests/__pycache__/test_environ_cli.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_fbo_py2py3.cpython-310.pyc b/kivy/tests/__pycache__/test_fbo_py2py3.cpython-310.pyc
new file mode 100644
index 0000000..c8af415
Binary files /dev/null and b/kivy/tests/__pycache__/test_fbo_py2py3.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_filechooser.cpython-310.pyc b/kivy/tests/__pycache__/test_filechooser.cpython-310.pyc
new file mode 100644
index 0000000..0f70a12
Binary files /dev/null and b/kivy/tests/__pycache__/test_filechooser.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_filechooser_unicode.cpython-310.pyc b/kivy/tests/__pycache__/test_filechooser_unicode.cpython-310.pyc
new file mode 100644
index 0000000..9e4105a
Binary files /dev/null and b/kivy/tests/__pycache__/test_filechooser_unicode.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_fonts.cpython-310.pyc b/kivy/tests/__pycache__/test_fonts.cpython-310.pyc
new file mode 100644
index 0000000..9f14642
Binary files /dev/null and b/kivy/tests/__pycache__/test_fonts.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_graphics.cpython-310.pyc b/kivy/tests/__pycache__/test_graphics.cpython-310.pyc
new file mode 100644
index 0000000..72040ae
Binary files /dev/null and b/kivy/tests/__pycache__/test_graphics.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_image.cpython-310.pyc b/kivy/tests/__pycache__/test_image.cpython-310.pyc
new file mode 100644
index 0000000..fe14c01
Binary files /dev/null and b/kivy/tests/__pycache__/test_image.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_imageloader.cpython-310.pyc b/kivy/tests/__pycache__/test_imageloader.cpython-310.pyc
new file mode 100644
index 0000000..10d8ad5
Binary files /dev/null and b/kivy/tests/__pycache__/test_imageloader.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_invalid_lang.cpython-310.pyc b/kivy/tests/__pycache__/test_invalid_lang.cpython-310.pyc
new file mode 100644
index 0000000..fb04a39
Binary files /dev/null and b/kivy/tests/__pycache__/test_invalid_lang.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_kivy_init.cpython-310.pyc b/kivy/tests/__pycache__/test_kivy_init.cpython-310.pyc
new file mode 100644
index 0000000..ea49380
Binary files /dev/null and b/kivy/tests/__pycache__/test_kivy_init.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_knspace.cpython-310.pyc b/kivy/tests/__pycache__/test_knspace.cpython-310.pyc
new file mode 100644
index 0000000..ab41474
Binary files /dev/null and b/kivy/tests/__pycache__/test_knspace.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_lang.cpython-310.pyc b/kivy/tests/__pycache__/test_lang.cpython-310.pyc
new file mode 100644
index 0000000..25ad761
Binary files /dev/null and b/kivy/tests/__pycache__/test_lang.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_lang_complex.cpython-310.pyc b/kivy/tests/__pycache__/test_lang_complex.cpython-310.pyc
new file mode 100644
index 0000000..cb82e82
Binary files /dev/null and b/kivy/tests/__pycache__/test_lang_complex.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_lang_pre_process_and_post_process.cpython-310.pyc b/kivy/tests/__pycache__/test_lang_pre_process_and_post_process.cpython-310.pyc
new file mode 100644
index 0000000..c08ae3f
Binary files /dev/null and b/kivy/tests/__pycache__/test_lang_pre_process_and_post_process.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_logger.cpython-310.pyc b/kivy/tests/__pycache__/test_logger.cpython-310.pyc
new file mode 100644
index 0000000..5061286
Binary files /dev/null and b/kivy/tests/__pycache__/test_logger.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_metrics.cpython-310.pyc b/kivy/tests/__pycache__/test_metrics.cpython-310.pyc
new file mode 100644
index 0000000..20ebf45
Binary files /dev/null and b/kivy/tests/__pycache__/test_metrics.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_module_inspector.cpython-310.pyc b/kivy/tests/__pycache__/test_module_inspector.cpython-310.pyc
new file mode 100644
index 0000000..e587432
Binary files /dev/null and b/kivy/tests/__pycache__/test_module_inspector.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_motion_event.cpython-310.pyc b/kivy/tests/__pycache__/test_motion_event.cpython-310.pyc
new file mode 100644
index 0000000..5fe42e9
Binary files /dev/null and b/kivy/tests/__pycache__/test_motion_event.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_mouse_hover_event.cpython-310.pyc b/kivy/tests/__pycache__/test_mouse_hover_event.cpython-310.pyc
new file mode 100644
index 0000000..59a6c60
Binary files /dev/null and b/kivy/tests/__pycache__/test_mouse_hover_event.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_mouse_multitouchsim.cpython-310.pyc b/kivy/tests/__pycache__/test_mouse_multitouchsim.cpython-310.pyc
new file mode 100644
index 0000000..72b79e8
Binary files /dev/null and b/kivy/tests/__pycache__/test_mouse_multitouchsim.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_multistroke.cpython-310.pyc b/kivy/tests/__pycache__/test_multistroke.cpython-310.pyc
new file mode 100644
index 0000000..5b807af
Binary files /dev/null and b/kivy/tests/__pycache__/test_multistroke.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_properties.cpython-310.pyc b/kivy/tests/__pycache__/test_properties.cpython-310.pyc
new file mode 100644
index 0000000..c88a7e4
Binary files /dev/null and b/kivy/tests/__pycache__/test_properties.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_resources.cpython-310.pyc b/kivy/tests/__pycache__/test_resources.cpython-310.pyc
new file mode 100644
index 0000000..0179f5f
Binary files /dev/null and b/kivy/tests/__pycache__/test_resources.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_rst_replace.cpython-310.pyc b/kivy/tests/__pycache__/test_rst_replace.cpython-310.pyc
new file mode 100644
index 0000000..a7f7466
Binary files /dev/null and b/kivy/tests/__pycache__/test_rst_replace.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_screen.cpython-310.pyc b/kivy/tests/__pycache__/test_screen.cpython-310.pyc
new file mode 100644
index 0000000..6e9e8b5
Binary files /dev/null and b/kivy/tests/__pycache__/test_screen.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_storage.cpython-310.pyc b/kivy/tests/__pycache__/test_storage.cpython-310.pyc
new file mode 100644
index 0000000..3676f9d
Binary files /dev/null and b/kivy/tests/__pycache__/test_storage.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_actionbar.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_actionbar.cpython-310.pyc
new file mode 100644
index 0000000..edd2977
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_actionbar.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_anchorlayout.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_anchorlayout.cpython-310.pyc
new file mode 100644
index 0000000..bda88e0
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_anchorlayout.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_asyncimage.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_asyncimage.cpython-310.pyc
new file mode 100644
index 0000000..47d19b3
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_asyncimage.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_boxlayout.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_boxlayout.cpython-310.pyc
new file mode 100644
index 0000000..68f6a30
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_boxlayout.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_bubble.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_bubble.cpython-310.pyc
new file mode 100644
index 0000000..af16512
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_bubble.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_carousel.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_carousel.cpython-310.pyc
new file mode 100644
index 0000000..ff9b0c7
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_carousel.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_dropdown.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_dropdown.cpython-310.pyc
new file mode 100644
index 0000000..0fd1128
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_dropdown.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_gridlayout.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_gridlayout.cpython-310.pyc
new file mode 100644
index 0000000..ff9c40e
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_gridlayout.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_layout.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_layout.cpython-310.pyc
new file mode 100644
index 0000000..2301b8d
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_layout.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_modal.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_modal.cpython-310.pyc
new file mode 100644
index 0000000..7258033
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_modal.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_recyclegridlayout.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_recyclegridlayout.cpython-310.pyc
new file mode 100644
index 0000000..10d2ddb
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_recyclegridlayout.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_relativelayout.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_relativelayout.cpython-310.pyc
new file mode 100644
index 0000000..5786a40
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_relativelayout.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_scrollview.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_scrollview.cpython-310.pyc
new file mode 100644
index 0000000..82a8dcb
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_scrollview.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_slider.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_slider.cpython-310.pyc
new file mode 100644
index 0000000..c2cc27b
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_slider.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_stacklayout.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_stacklayout.cpython-310.pyc
new file mode 100644
index 0000000..44f3970
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_stacklayout.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_textinput.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_textinput.cpython-310.pyc
new file mode 100644
index 0000000..22f8050
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_textinput.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_translate_coordinates.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_translate_coordinates.cpython-310.pyc
new file mode 100644
index 0000000..b6c782f
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_translate_coordinates.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_videoplayer.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_videoplayer.cpython-310.pyc
new file mode 100644
index 0000000..b6ec1bf
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_videoplayer.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_uix_widget.cpython-310.pyc b/kivy/tests/__pycache__/test_uix_widget.cpython-310.pyc
new file mode 100644
index 0000000..5e179f7
Binary files /dev/null and b/kivy/tests/__pycache__/test_uix_widget.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_urlrequest.cpython-310.pyc b/kivy/tests/__pycache__/test_urlrequest.cpython-310.pyc
new file mode 100644
index 0000000..126ee2c
Binary files /dev/null and b/kivy/tests/__pycache__/test_urlrequest.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_utils.cpython-310.pyc b/kivy/tests/__pycache__/test_utils.cpython-310.pyc
new file mode 100644
index 0000000..e2a6a25
Binary files /dev/null and b/kivy/tests/__pycache__/test_utils.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_vector.cpython-310.pyc b/kivy/tests/__pycache__/test_vector.cpython-310.pyc
new file mode 100644
index 0000000..623cf32
Binary files /dev/null and b/kivy/tests/__pycache__/test_vector.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_video.cpython-310.pyc b/kivy/tests/__pycache__/test_video.cpython-310.pyc
new file mode 100644
index 0000000..10508f8
Binary files /dev/null and b/kivy/tests/__pycache__/test_video.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_weakmethod.cpython-310.pyc b/kivy/tests/__pycache__/test_weakmethod.cpython-310.pyc
new file mode 100644
index 0000000..0994bc0
Binary files /dev/null and b/kivy/tests/__pycache__/test_weakmethod.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_widget.cpython-310.pyc b/kivy/tests/__pycache__/test_widget.cpython-310.pyc
new file mode 100644
index 0000000..223f802
Binary files /dev/null and b/kivy/tests/__pycache__/test_widget.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_widget_walk.cpython-310.pyc b/kivy/tests/__pycache__/test_widget_walk.cpython-310.pyc
new file mode 100644
index 0000000..16f14c4
Binary files /dev/null and b/kivy/tests/__pycache__/test_widget_walk.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_window_base.cpython-310.pyc b/kivy/tests/__pycache__/test_window_base.cpython-310.pyc
new file mode 100644
index 0000000..5a9073f
Binary files /dev/null and b/kivy/tests/__pycache__/test_window_base.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/test_window_info.cpython-310.pyc b/kivy/tests/__pycache__/test_window_info.cpython-310.pyc
new file mode 100644
index 0000000..f7f0d67
Binary files /dev/null and b/kivy/tests/__pycache__/test_window_info.cpython-310.pyc differ
diff --git a/kivy/tests/__pycache__/visual_test_label.cpython-310.pyc b/kivy/tests/__pycache__/visual_test_label.cpython-310.pyc
new file mode 100644
index 0000000..ec492b7
Binary files /dev/null and b/kivy/tests/__pycache__/visual_test_label.cpython-310.pyc differ
diff --git a/kivy/tests/async_common.py b/kivy/tests/async_common.py
new file mode 100644
index 0000000..8be1c80
--- /dev/null
+++ b/kivy/tests/async_common.py
@@ -0,0 +1,568 @@
+"""
+.. warning::
+
+    The classes in this file are internal and may well be removed to an
+    external kivy-pytest package or similar in the future. Use at your own
+    risk.
+"""
+import random
+import time
+import math
+import os
+from collections import deque
+
+from kivy.tests import UnitTestTouch
+
+__all__ = ('UnitKivyApp', )
+
+
+class AsyncUnitTestTouch(UnitTestTouch):
+
+    def __init__(self, *largs, **kwargs):
+        self.grab_exclusive_class = None
+        self.is_touch = True
+        super(AsyncUnitTestTouch, self).__init__(*largs, **kwargs)
+
+    def touch_down(self, *args):
+        self.eventloop._dispatch_input("begin", self)
+
+    def touch_move(self, x, y):
+        win = self.eventloop.window
+        self.move({
+            "x": x / (win.width - 1.0),
+            "y": y / (win.height - 1.0)
+        })
+        self.eventloop._dispatch_input("update", self)
+
+    def touch_up(self, *args):
+        self.eventloop._dispatch_input("end", self)
+
+
+_unique_value = object
+
+
+class WidgetResolver(object):
+    """It assumes that the widget tree strictly forms a DAG.
+    """
+
+    base_widget = None
+
+    matched_widget = None
+
+    _kwargs_filter = {}
+
+    _funcs_filter = []
+
+    def __init__(self, base_widget, **kwargs):
+        self.base_widget = base_widget
+        self._kwargs_filter = {}
+        self._funcs_filter = []
+        super(WidgetResolver, self).__init__(**kwargs)
+
+    def __call__(self):
+        if self.matched_widget is not None:
+            return self.matched_widget
+
+        if not self._kwargs_filter and not self._funcs_filter:
+            return self.base_widget
+        return None
+
+    def match(self, **kwargs_filter):
+        self._kwargs_filter.update(kwargs_filter)
+
+    def match_funcs(self, funcs_filter=()):
+        self._funcs_filter.extend(funcs_filter)
+
+    def check_widget(self, widget):
+        if not all(func(widget) for func in self._funcs_filter):
+            return False
+
+        for attr, val in self._kwargs_filter.items():
+            if getattr(widget, attr, _unique_value) != val:
+                return False
+
+        return True
+
+    def not_found(self, op):
+        raise ValueError(
+            'Cannot find widget matching <{}, {}> starting from base '
+            'widget "{}" doing "{}" traversal'.format(
+                self._kwargs_filter, self._funcs_filter, self.base_widget, op))
+
+    def down(self, **kwargs_filter):
+        self.match(**kwargs_filter)
+        check = self.check_widget
+
+        fifo = deque([self.base_widget])
+        while fifo:
+            widget = fifo.popleft()
+            if check(widget):
+                return WidgetResolver(base_widget=widget)
+
+            fifo.extend(widget.children)
+
+        self.not_found('down')
+
+    def up(self, **kwargs_filter):
+        self.match(**kwargs_filter)
+        check = self.check_widget
+
+        parent = self.base_widget
+        while parent is not None:
+            if check(parent):
+                return WidgetResolver(base_widget=parent)
+
+            new_parent = parent.parent
+            # Window is its own parent oO
+            if new_parent is parent:
+                break
+            parent = new_parent
+
+        self.not_found('up')
+
+    def family_up(self, **kwargs_filter):
+        self.match(**kwargs_filter)
+        check = self.check_widget
+
+        base_widget = self.base_widget
+        already_checked_base = None
+        while base_widget is not None:
+            fifo = deque([base_widget])
+            while fifo:
+                widget = fifo.popleft()
+                # don't check the child we checked before moving up
+                if widget is already_checked_base:
+                    continue
+
+                if check(widget):
+                    return WidgetResolver(base_widget=widget)
+
+                fifo.extend(widget.children)
+
+            already_checked_base = base_widget
+            new_base_widget = base_widget.parent
+            # Window is its own parent oO
+            if new_base_widget is base_widget:
+                break
+            base_widget = new_base_widget
+
+        self.not_found('family_up')
+
+
+class UnitKivyApp(object):
+    """Base class to use with async test apps.
+
+    .. warning::
+
+        The classes in this file are internal and may well be removed to an
+        external kivy-pytest package or similar in the future. Use at your own
+        risk.
+    """
+
+    app_has_started = False
+
+    app_has_stopped = False
+
+    async_sleep = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        def started_app(*largs):
+            self.app_has_started = True
+        self.fbind('on_start', started_app)
+
+        def stopped_app(*largs):
+            self.app_has_stopped = True
+        self.fbind('on_stop', stopped_app)
+
+    def set_async_lib(self, async_lib):
+        from kivy.clock import Clock
+        if async_lib is not None:
+            Clock.init_async_lib(async_lib)
+        self.async_sleep = Clock._async_lib.sleep
+
+    async def async_run(self, async_lib=None):
+        self.set_async_lib(async_lib)
+        return await super(UnitKivyApp, self).async_run(async_lib=async_lib)
+
+    def resolve_widget(self, base_widget=None):
+        if base_widget is None:
+            from kivy.core.window import Window
+            base_widget = Window
+        return WidgetResolver(base_widget=base_widget)
+
+    async def wait_clock_frames(self, n, sleep_time=1 / 60.):
+        from kivy.clock import Clock
+        frames_start = Clock.frames
+        while Clock.frames < frames_start + n:
+            await self.async_sleep(sleep_time)
+
+    def get_widget_pos_pixel(self, widget, positions):
+        from kivy.graphics import Fbo, ClearColor, ClearBuffers
+
+        canvas_parent_index = -2
+        if widget.parent is not None:
+            canvas_parent_index = widget.parent.canvas.indexof(widget.canvas)
+            if canvas_parent_index > -1:
+                widget.parent.canvas.remove(widget.canvas)
+
+        w, h = int(widget.width), int(widget.height)
+        fbo = Fbo(size=(w, h), with_stencilbuffer=True)
+
+        with fbo:
+            ClearColor(0, 0, 0, 0)
+            ClearBuffers()
+
+        fbo.add(widget.canvas)
+        fbo.draw()
+        pixels = fbo.pixels
+        fbo.remove(widget.canvas)
+
+        if widget.parent is not None and canvas_parent_index > -1:
+            widget.parent.canvas.insert(canvas_parent_index, widget.canvas)
+
+        values = []
+        for x, y in positions:
+            x = int(x)
+            y = int(y)
+            i = y * w * 4 + x * 4
+            values.append(tuple(pixels[i:i + 4]))
+
+        return values
+
+    async def do_touch_down_up(
+            self, pos=None, widget=None, duration=.2, pos_jitter=None,
+            widget_jitter=False, jitter_dt=1 / 15., end_on_pos=False):
+        if widget is None:
+            x, y = pos
+        else:
+            if pos is None:
+                x, y = widget.to_window(*widget.center)
+            else:
+                x, y = widget.to_window(*pos, initial=False)
+        touch = AsyncUnitTestTouch(x, y)
+
+        ts = time.perf_counter()
+        touch.touch_down()
+        await self.wait_clock_frames(1)
+        yield 'down', touch.pos
+
+        if not pos_jitter and not widget_jitter:
+            await self.async_sleep(duration)
+            touch.touch_up()
+            await self.wait_clock_frames(1)
+            yield 'up', touch.pos
+
+            return
+
+        moved = False
+        if pos_jitter:
+            dx, dy = pos_jitter
+        else:
+            dx = widget.width / 2.
+            dy = widget.height / 2.
+
+        while time.perf_counter() - ts < duration:
+            moved = True
+            await self.async_sleep(jitter_dt)
+
+            touch.touch_move(
+                x + (random.random() * 2 - 1) * dx,
+                y + (random.random() * 2 - 1) * dy
+            )
+            await self.wait_clock_frames(1)
+            yield 'move', touch.pos
+
+        if end_on_pos and moved:
+            touch.touch_move(x, y)
+            await self.wait_clock_frames(1)
+            yield 'move', touch.pos
+
+        touch.touch_up()
+        await self.wait_clock_frames(1)
+        yield 'up', touch.pos
+
+    async def do_touch_drag(
+            self, pos=None, widget=None,
+            widget_loc=('center_x', 'center_y'), dx=0, dy=0,
+            target_pos=None, target_widget=None, target_widget_offset=(0, 0),
+            target_widget_loc=('center_x', 'center_y'), long_press=0,
+            duration=.2, drag_n=5):
+        """Initiates a touch down, followed by some dragging to a target
+        location, ending with a touch up.
+
+        `origin`: These parameters specify where the drag starts.
+        - If ``widget`` is None, it starts at ``pos`` (in window coordinates).
+          If ``dx``/``dy`` is used, it is in the window coordinate system also.
+        - If ``pos`` is None, it starts on the ``widget`` as specified by
+          ``widget_loc``. If ``dx``/``dy`` is used, it is in the ``widget``
+          coordinate system.
+        - If neither is None, it starts at ``pos``, but in the ``widget``'s
+          coordinate system (:meth:`~kivy.uix.widget.Widget.to_window` is used
+          on it). If ``dx``/``dy`` is used, it is in the ``widget``
+          coordinate system.
+
+        `target`: These parameters specify where the drag ends.
+        - If ``target_pos`` and ``target_widget`` is None, then ``dx`` and
+          ``dy`` is used relative to the position where the drag started.
+        - If ``target_widget`` is None, it ends at ``target_pos``
+          (in window coordinates).
+        - If ``target_pos`` is None, it ends on the ``target_widget`` as
+          specified by ``target_widget_loc``. ``target_widget_offset``, is an
+          additional ``(x, y)`` offset relative to ``target_widget_loc``.
+        - If neither is None, it starts at ``target_pos``, but in the
+          ``target_widget``'s coordinate system
+          (:meth:`~kivy.uix.widget.Widget.to_window` is used on it).
+
+        When ``widget`` and/or ``target_widget`` are specified, ``widget_loc``
+        and ``target_widget_loc``, respectively, indicate where on the widget
+        the drag starts/ends. It is a a tuple with property names of the widget
+        to loop up to get the value. The default is
+        ``('center_x', 'center_y')`` so the drag would start/end in the
+        widget's center.
+        """
+        if widget is None:
+            x, y = pos
+            tx, ty = x + dx, y + dy
+        else:
+            if pos is None:
+                w_x = getattr(widget, widget_loc[0])
+                w_y = getattr(widget, widget_loc[1])
+                x, y = widget.to_window(w_x, w_y)
+                tx, ty = widget.to_window(w_x + dx, w_y + dy)
+            else:
+                x, y = widget.to_window(*pos, initial=False)
+                tx, ty = widget.to_window(
+                    pos[0] + dx, pos[1] + dy, initial=False)
+
+        if target_pos is not None:
+            if target_widget is None:
+                tx, ty = target_pos
+            else:
+                tx, ty = target_pos = target_widget.to_window(
+                    *target_pos, initial=False)
+        elif target_widget is not None:
+            x_off, y_off = target_widget_offset
+            w_x = getattr(target_widget, target_widget_loc[0]) + x_off
+            w_y = getattr(target_widget, target_widget_loc[1]) + y_off
+            tx, ty = target_pos = target_widget.to_window(w_x, w_y)
+        else:
+            target_pos = tx, ty
+
+        touch = AsyncUnitTestTouch(x, y)
+
+        touch.touch_down()
+        await self.wait_clock_frames(1)
+        if long_press:
+            await self.async_sleep(long_press)
+        yield 'down', touch.pos
+
+        dx = (tx - x) / drag_n
+        dy = (ty - y) / drag_n
+
+        ts0 = time.perf_counter()
+        for i in range(drag_n):
+            await self.async_sleep(
+                max(0., duration - (time.perf_counter() - ts0)) / (drag_n - i))
+
+            touch.touch_move(x + (i + 1) * dx, y + (i + 1) * dy)
+            await self.wait_clock_frames(1)
+            yield 'move', touch.pos
+
+        if touch.pos != target_pos:
+            touch.touch_move(*target_pos)
+            await self.wait_clock_frames(1)
+            yield 'move', touch.pos
+
+        touch.touch_up()
+        await self.wait_clock_frames(1)
+        yield 'up', touch.pos
+
+    async def do_touch_drag_follow(
+            self, pos=None, widget=None,
+            widget_loc=('center_x', 'center_y'),
+            target_pos=None, target_widget=None, target_widget_offset=(0, 0),
+            target_widget_loc=('center_x', 'center_y'), long_press=0,
+            duration=.2, drag_n=5, max_n=25):
+        """Very similar to :meth:`do_touch_drag`, except it follows the target
+        widget, even if the target widget moves as a result of the drag, the
+        drag will follow it until it's on the target widget.
+
+        `origin`: These parameters specify where the drag starts.
+        - If ``widget`` is None, it starts at ``pos`` (in window coordinates).
+        - If ``pos`` is None, it starts on the ``widget`` as specified by
+          ``widget_loc``.
+        - If neither is None, it starts at ``pos``, but in the ``widget``'s
+          coordinate system (:meth:`~kivy.uix.widget.Widget.to_window` is used
+          on it).
+
+        `target`: These parameters specify where the drag ends.
+        - If ``target_pos`` is None, it ends on the ``target_widget`` as
+          specified by ``target_widget_loc``. ``target_widget_offset``, is an
+          additional ``(x, y)`` offset relative to ``target_widget_loc``.
+        - If ``target_pos`` is not None, it starts at ``target_pos``, but in
+          the ``target_widget``'s coordinate system
+          (:meth:`~kivy.uix.widget.Widget.to_window` is used on it).
+
+        When ``widget`` and/or ``target_widget`` are specified, ``widget_loc``
+        and ``target_widget_loc``, respectively, indicate where on the widget
+        the drag starts/ends. It is a a tuple with property names of the widget
+        to loop up to get the value. The default is
+        ``('center_x', 'center_y')`` so the drag would start/end in the
+        widget's center.
+        """
+        if widget is None:
+            x, y = pos
+        else:
+            if pos is None:
+                w_x = getattr(widget, widget_loc[0])
+                w_y = getattr(widget, widget_loc[1])
+                x, y = widget.to_window(w_x, w_y)
+            else:
+                x, y = widget.to_window(*pos, initial=False)
+
+        if target_widget is None:
+            raise ValueError('target_widget must be specified')
+
+        def get_target():
+            if target_pos is not None:
+                return target_widget.to_window(*target_pos, initial=False)
+            else:
+                x_off, y_off = target_widget_offset
+                wt_x = getattr(target_widget, target_widget_loc[0]) + x_off
+                wt_y = getattr(target_widget, target_widget_loc[1]) + y_off
+                return target_widget.to_window(wt_x, wt_y)
+
+        touch = AsyncUnitTestTouch(x, y)
+
+        touch.touch_down()
+        await self.wait_clock_frames(1)
+        if long_press:
+            await self.async_sleep(long_press)
+        yield 'down', touch.pos
+
+        ts0 = time.perf_counter()
+        tx, ty = get_target()
+        i = 0
+        while not (math.isclose(touch.x, tx) and math.isclose(touch.y, ty)):
+            if i >= max_n:
+                raise Exception(
+                    'Exceeded the maximum number of iterations, '
+                    'but {} != {}'.format(touch.pos, (tx, ty)))
+
+            rem_i = max(1, drag_n - i)
+            rem_t = max(0., duration - (time.perf_counter() - ts0)) / rem_i
+            i += 1
+            await self.async_sleep(rem_t)
+
+            x, y = touch.pos
+            touch.touch_move(x + (tx - x) / rem_i, y + (ty - y) / rem_i)
+            await self.wait_clock_frames(1)
+            yield 'move', touch.pos
+            tx, ty = get_target()
+
+        touch.touch_up()
+        await self.wait_clock_frames(1)
+        yield 'up', touch.pos
+
+    async def do_touch_drag_path(
+            self, path, axis_widget=None, long_press=0, duration=.2):
+        """Drags the touch along the specified path.
+
+        :parameters:
+
+            `path`: list
+                A list of position tuples the touch will follow. The first
+                item is used for the touch down and the rest for the move.
+            `axis_widget`: a Widget
+                If None, the path coordinates is in window coordinates,
+                otherwise, we will first transform the path coordinates
+                to window coordinates using
+                :meth:`~kivy.uix.widget.Widget.to_window` of the specified
+                widget.
+        """
+        if axis_widget is not None:
+            path = [axis_widget.to_window(*p, initial=False) for p in path]
+        x, y = path[0]
+        path = path[1:]
+
+        touch = AsyncUnitTestTouch(x, y)
+
+        touch.touch_down()
+        await self.wait_clock_frames(1)
+        if long_press:
+            await self.async_sleep(long_press)
+        yield 'down', touch.pos
+
+        ts0 = time.perf_counter()
+        n = len(path)
+        for i, (x2, y2) in enumerate(path):
+            await self.async_sleep(
+                max(0., duration - (time.perf_counter() - ts0)) / (n - i))
+
+            touch.touch_move(x2, y2)
+            await self.wait_clock_frames(1)
+            yield 'move', touch.pos
+
+        touch.touch_up()
+        await self.wait_clock_frames(1)
+        yield 'up', touch.pos
+
+    async def do_keyboard_key(
+            self, key, modifiers=(), duration=.05, num_press=1):
+        from kivy.core.window import Window
+        if key == ' ':
+            key = 'spacebar'
+        key_lower = key.lower()
+        key_code = Window._system_keyboard.string_to_keycode(key_lower)
+
+        known_modifiers = {'shift', 'alt', 'ctrl', 'meta'}
+        if set(modifiers) - known_modifiers:
+            raise ValueError('Unknown modifiers "{}"'.
+                             format(set(modifiers) - known_modifiers))
+
+        special_keys = {
+            27: 'escape',
+            9: 'tab',
+            8: 'backspace',
+            13: 'enter',
+            127: 'del',
+            271: 'enter',
+            273: 'up',
+            274: 'down',
+            275: 'right',
+            276: 'left',
+            278: 'home',
+            279: 'end',
+            280: 'pgup',
+            281: 'pgdown',
+            300: 'numlock',
+            301: 'capslock',
+            145: 'screenlock',
+        }
+
+        text = None
+        try:
+            text = chr(key_code)
+            if key_lower != key:
+                text = key
+        except ValueError:
+            pass
+
+        dt = duration / num_press
+        for i in range(num_press):
+            await self.async_sleep(dt)
+
+            Window.dispatch('on_key_down', key_code, 0, text, modifiers)
+            if (key not in known_modifiers and
+                    key_code not in special_keys and
+                    not (known_modifiers & set(modifiers))):
+                Window.dispatch('on_textinput', text)
+
+            await self.wait_clock_frames(1)
+            yield 'down', (key, key_code, 0, text, modifiers)
+
+        Window.dispatch('on_key_up', key_code, 0)
+        await self.wait_clock_frames(1)
+        yield 'up', (key, key_code, 0, text, modifiers)
diff --git a/kivy/tests/common.py b/kivy/tests/common.py
new file mode 100644
index 0000000..b42023b
--- /dev/null
+++ b/kivy/tests/common.py
@@ -0,0 +1,524 @@
+'''
+This is a extended unittest module for Kivy, to make unittests based on
+graphics with an OpenGL context.
+
+The idea is to render a Widget tree, and after 1, 2 or more frames, a
+screenshot will be made and be compared to the original one.
+If no screenshot exists for the current test, the very first one will be used.
+
+The screenshots live in the 'kivy/tests/results' folder and are in PNG format,
+320x240 pixels.
+'''
+
+__all__ = (
+    'GraphicUnitTest', 'UnitTestTouch', 'UTMotionEvent', 'async_run',
+    'requires_graphics', 'ensure_web_server')
+
+import unittest
+import logging
+import pytest
+import sys
+from functools import partial
+import os
+import threading
+from kivy.graphics.cgl import cgl_get_backend_name
+from kivy.input.motionevent import MotionEvent
+log = logging.getLogger('unittest')
+
+
+_base = object
+if 'mock' != cgl_get_backend_name():
+    # check what the gl backend might be, we can't know for sure
+    # what it'll be until actually initialized by the window.
+    _base = unittest.TestCase
+
+make_screenshots = os.environ.get('KIVY_UNITTEST_SCREENSHOTS')
+http_server = None
+http_server_ready = threading.Event()
+kivy_eventloop = os.environ.get('KIVY_EVENTLOOP', 'asyncio')
+
+
+def requires_graphics(func):
+    if 'mock' == cgl_get_backend_name():
+        return pytest.mark.skip(
+            reason='Skipping because gl backend is set to mock')(func)
+    return func
+
+
+def ensure_web_server(root=None):
+    if http_server is not None:
+        return True
+
+    if not root:
+        root = os.path.join(os.path.dirname(__file__), "..", "..")
+    need_chdir = sys.version_info.major == 3 and sys.version_info.minor <= 6
+    curr_dir = os.getcwd()
+
+    def _start_web_server():
+        global http_server
+        from http.server import SimpleHTTPRequestHandler
+        from socketserver import TCPServer
+
+        try:
+            if need_chdir:
+                os.chdir(root)
+                handler = SimpleHTTPRequestHandler
+            else:
+                handler = partial(SimpleHTTPRequestHandler, directory=root)
+
+            http_server = TCPServer(
+                ("", 8000), handler, bind_and_activate=False)
+            http_server.daemon_threads = True
+            http_server.allow_reuse_address = True
+            http_server.server_bind()
+            http_server.server_activate()
+            http_server_ready.set()
+            http_server.serve_forever()
+        except:
+            import traceback
+            traceback.print_exc()
+        finally:
+            http_server = None
+            http_server_ready.set()
+
+            if need_chdir:
+                os.chdir(curr_dir)
+
+    th = threading.Thread(target=_start_web_server)
+    th.daemon = True
+    th.start()
+    http_server_ready.wait()
+    if http_server is None:
+        raise Exception("Unable to start webserver")
+
+
+class GraphicUnitTest(_base):
+    framecount = 0
+
+    def _force_refresh(self, *largs):
+        # this prevent in some case to be stuck if the screen doesn't refresh
+        # and we wait for a number of self.framecount that never goes down
+        from kivy.base import EventLoop
+        win = EventLoop.window
+        if win and win.canvas:
+            win.canvas.ask_update()
+
+    def render(self, root, framecount=1):
+        '''Call rendering process using the `root` widget.
+        The screenshot will be done in `framecount` frames.
+        '''
+        from kivy.base import runTouchApp
+        from kivy.clock import Clock
+        self.framecount = framecount
+        try:
+            Clock.schedule_interval(self._force_refresh, 1)
+            runTouchApp(root)
+        finally:
+            Clock.unschedule(self._force_refresh)
+
+        # reset for the next test, but nobody will know if it will be used :/
+        if self.test_counter != 0:
+            self.tearDown(fake=True)
+            self.setUp()
+
+    def run(self, *args, **kwargs):
+        '''Extend the run of unittest, to check if results directory have been
+        found. If no results directory exists, the test will be ignored.
+        '''
+        from os.path import join, dirname, exists
+        results_dir = join(dirname(__file__), 'results')
+        if make_screenshots and not exists(results_dir):
+            log.warning('No result directory found, cancel test.')
+            os.mkdir(results_dir)
+        self.test_counter = 0
+        self.results_dir = results_dir
+        self.test_failed = False
+        return super(GraphicUnitTest, self).run(*args, **kwargs)
+
+    def setUp(self):
+        '''Prepare the graphic test, with:
+            - Window size fixed to 320x240
+            - Default kivy configuration
+            - Without any kivy input
+        '''
+
+        # use default kivy configuration (don't load user file.)
+        from os import environ
+        environ['KIVY_USE_DEFAULTCONFIG'] = '1'
+
+        # force window size + remove all inputs
+        from kivy.config import Config
+        Config.set('graphics', 'width', '320')
+        Config.set('graphics', 'height', '240')
+        for items in Config.items('input'):
+            Config.remove_option('input', items[0])
+
+        # bind ourself for the later screenshot
+        from kivy.core.window import Window
+        self.Window = Window
+        Window.bind(on_flip=self.on_window_flip)
+
+        # ensure our window is correctly created
+        Window.create_window()
+        Window.register()
+        Window.initialized = True
+        Window.close = lambda *s: None
+        self.clear_window_and_event_loop()
+
+    def clear_window_and_event_loop(self):
+        from kivy.base import EventLoop
+        window = self.Window
+        for child in window.children[:]:
+            window.remove_widget(child)
+        window.canvas.before.clear()
+        window.canvas.clear()
+        window.canvas.after.clear()
+        EventLoop.touches.clear()
+        for post_proc in EventLoop.postproc_modules:
+            if hasattr(post_proc, 'touches'):
+                post_proc.touches.clear()
+            elif hasattr(post_proc, 'last_touches'):
+                post_proc.last_touches.clear()
+
+    def on_window_flip(self, window):
+        '''Internal method to be called when the window have just displayed an
+        image.
+        When an image is showed, we decrement our framecount. If framecount is
+        come to 0, we are taking the screenshot.
+
+        The screenshot is done in a temporary place, and is compared to the
+        original one -> test ok/ko.
+        If no screenshot is available in the results directory, a new one will
+        be created.
+        '''
+        from kivy.base import EventLoop
+        from tempfile import mkstemp
+        from os.path import join, exists
+        from os import unlink, close
+        from shutil import move, copy
+
+        # don't save screenshot until we have enough frames.
+        # log.debug('framecount %d' % self.framecount)
+        # ! check if there is 'framecount', otherwise just
+        # ! assume zero e.g. if handling runTouchApp manually
+        self.framecount = getattr(self, 'framecount', 0) - 1
+        if self.framecount > 0:
+            return
+
+        # don't create screenshots if not requested manually
+        if not make_screenshots:
+            EventLoop.stop()
+            return
+
+        reffn = None
+        match = False
+        try:
+            # just get a temporary name
+            fd, tmpfn = mkstemp(suffix='.png', prefix='kivyunit-')
+            close(fd)
+            unlink(tmpfn)
+
+            # get a filename for the current unit test
+            self.test_counter += 1
+            test_uid = '%s-%d.png' % (
+                '_'.join(self.id().split('.')[-2:]),
+                self.test_counter)
+
+            # capture the screen
+            log.info('Capturing screenshot for %s' % test_uid)
+            tmpfn = window.screenshot(tmpfn)
+            log.info('Capture saved at %s' % tmpfn)
+
+            # search the file to compare to
+            reffn = join(self.results_dir, test_uid)
+            log.info('Compare with %s' % reffn)
+
+            # get sourcecode
+            import inspect
+            frame = inspect.getouterframes(inspect.currentframe())[6]
+            sourcecodetab, line = inspect.getsourcelines(frame[0])
+            line = frame[2] - line
+            currentline = sourcecodetab[line]
+            sourcecodetab[line] = '<span style="color: red;">%s</span>' % (
+                currentline)
+            sourcecode = ''.join(sourcecodetab)
+            sourcecodetab[line] = '>>>>>>>>\n%s<<<<<<<<\n' % currentline
+            sourcecodeask = ''.join(sourcecodetab)
+
+            if not exists(reffn):
+                log.info('No image reference, move %s as ref ?' % test_uid)
+                if self.interactive_ask_ref(sourcecodeask, tmpfn, self.id()):
+                    move(tmpfn, reffn)
+                    tmpfn = reffn
+                    log.info('Image used as reference')
+                    match = True
+                else:
+                    log.info('Image discarded')
+            else:
+                from kivy.core.image import Image as CoreImage
+                s1 = CoreImage(tmpfn, keep_data=True)
+                sd1 = s1.image._data[0].data
+                s2 = CoreImage(reffn, keep_data=True)
+                sd2 = s2.image._data[0].data
+                if sd1 != sd2:
+                    log.critical(
+                        '%s at render() #%d, images are different.' % (
+                            self.id(), self.test_counter))
+                    if self.interactive_ask_diff(sourcecodeask,
+                                                 tmpfn, reffn, self.id()):
+                        log.critical('user ask to use it as ref.')
+                        move(tmpfn, reffn)
+                        tmpfn = reffn
+                        match = True
+                    else:
+                        self.test_failed = True
+                else:
+                    match = True
+
+            # generate html
+            from os.path import join, dirname, exists, basename
+            from os import mkdir
+            build_dir = join(dirname(__file__), 'build')
+            if not exists(build_dir):
+                mkdir(build_dir)
+            copy(reffn, join(build_dir, 'ref_%s' % basename(reffn)))
+            if tmpfn != reffn:
+                copy(tmpfn, join(build_dir, 'test_%s' % basename(reffn)))
+            with open(join(build_dir, 'index.html'), 'at') as fd:
+                color = '#ffdddd' if not match else '#ffffff'
+                fd.write('<div style="background-color: %s">' % color)
+                fd.write('<h2>%s #%d</h2>' % (self.id(), self.test_counter))
+                fd.write('<table><tr><th>Reference</th>'
+                         '<th>Test</th>'
+                         '<th>Comment</th>')
+                fd.write('<tr><td><img src="ref_%s"/></td>' %
+                         basename(reffn))
+                if tmpfn != reffn:
+                    fd.write('<td><img src="test_%s"/></td>' %
+                             basename(reffn))
+                else:
+                    fd.write('<td>First time, no comparison.</td>')
+                fd.write('<td><pre>%s</pre></td>' % sourcecode)
+                fd.write('</table></div>')
+        finally:
+            try:
+                if reffn != tmpfn:
+                    unlink(tmpfn)
+            except:
+                pass
+            EventLoop.stop()
+
+    def tearDown(self, fake=False):
+        '''When the test is finished, stop the application, and unbind our
+        current flip callback.
+        '''
+        from kivy.base import stopTouchApp
+        from kivy.core.window import Window
+        Window.unbind(on_flip=self.on_window_flip)
+        self.clear_window_and_event_loop()
+        self.Window = None
+        stopTouchApp()
+        if not fake and self.test_failed:
+            self.assertTrue(False)
+        super(GraphicUnitTest, self).tearDown()
+
+    def interactive_ask_ref(self, code, imagefn, testid):
+        from os import environ
+        if 'UNITTEST_INTERACTIVE' not in environ:
+            return True
+
+        from tkinter import Tk, Label, LEFT, RIGHT, BOTTOM, Button
+        from PIL import Image, ImageTk
+
+        self.retval = False
+
+        root = Tk()
+
+        def do_close():
+            root.destroy()
+
+        def do_yes():
+            self.retval = True
+            do_close()
+
+        image = Image.open(imagefn)
+        photo = ImageTk.PhotoImage(image)
+        Label(root, text='The test %s\nhave no reference.' % testid).pack()
+        Label(root, text='Use this image as a reference ?').pack()
+        Label(root, text=code, justify=LEFT).pack(side=RIGHT)
+        Label(root, image=photo).pack(side=LEFT)
+        Button(root, text='Use as reference', command=do_yes).pack(side=BOTTOM)
+        Button(root, text='Discard', command=do_close).pack(side=BOTTOM)
+        root.mainloop()
+
+        return self.retval
+
+    def interactive_ask_diff(self, code, tmpfn, reffn, testid):
+        from os import environ
+        if 'UNITTEST_INTERACTIVE' not in environ:
+            return False
+
+        from tkinter import Tk, Label, LEFT, RIGHT, BOTTOM, Button
+        from PIL import Image, ImageTk
+
+        self.retval = False
+
+        root = Tk()
+
+        def do_close():
+            root.destroy()
+
+        def do_yes():
+            self.retval = True
+            do_close()
+
+        phototmp = ImageTk.PhotoImage(Image.open(tmpfn))
+        photoref = ImageTk.PhotoImage(Image.open(reffn))
+        Label(root, text='The test %s\nhave generated an different'
+              'image as the reference one..' % testid).pack()
+        Label(root, text='Which one is good ?').pack()
+        Label(root, text=code, justify=LEFT).pack(side=RIGHT)
+        Label(root, image=phototmp).pack(side=RIGHT)
+        Label(root, image=photoref).pack(side=LEFT)
+        Button(root, text='Use the new image -->',
+               command=do_yes).pack(side=BOTTOM)
+        Button(root, text='<-- Use the reference',
+               command=do_close).pack(side=BOTTOM)
+        root.mainloop()
+
+        return self.retval
+
+    def advance_frames(self, count):
+        '''Render the new frames and:
+
+        * tick the Clock
+        * dispatch input from all registered providers
+        * flush all the canvas operations
+        * redraw Window canvas if necessary
+        '''
+        from kivy.base import EventLoop
+        for i in range(count):
+            EventLoop.idle()
+
+
+class UnitTestTouch(MotionEvent):
+    '''Custom MotionEvent representing a single touch. Similar to `on_touch_*`
+    methods from the Widget class, this one introduces:
+
+    * touch_down
+    * touch_move
+    * touch_up
+
+    Create a new touch with::
+
+        touch = UnitTestTouch(x, y)
+
+    then you press it on the default position with::
+
+        touch.touch_down()
+
+    or move it or even release with these simple calls::
+
+        touch.touch_move(new_x, new_y)
+        touch.touch_up()
+    '''
+
+    def __init__(self, x, y):
+        '''Create a MotionEvent instance with X and Y of the first
+        position a touch is at.
+        '''
+        from kivy.base import EventLoop
+        self.eventloop = EventLoop
+        win = EventLoop.window
+        super(UnitTestTouch, self).__init__(
+            # device, (tuio) id, args
+            self.__class__.__name__, 99, {
+                "x": x / (win.width - 1.0),
+                "y": y / (win.height - 1.0),
+            },
+            is_touch=True,
+            type_id='touch'
+        )
+        # set profile to accept x, y and pos properties
+        self.profile = ['pos']
+
+    def touch_down(self, *args):
+        self.eventloop.post_dispatch_input("begin", self)
+
+    def touch_move(self, x, y):
+        win = self.eventloop.window
+        self.move({
+            "x": x / (win.width - 1.0),
+            "y": y / (win.height - 1.0)
+        })
+        self.eventloop.post_dispatch_input("update", self)
+
+    def touch_up(self, *args):
+        self.eventloop.post_dispatch_input("end", self)
+
+    def depack(self, args):
+        # set sx/sy properties to ratio (e.g. X / win.width)
+        self.sx = args['x']
+        self.sy = args['y']
+        # run depack after we set the values
+        super().depack(args)
+
+
+# https://gist.github.com/tito/f111b6916aa6a4ed0851
+# subclass for touch event in unit test
+class UTMotionEvent(MotionEvent):
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault('is_touch', True)
+        kwargs.setdefault('type_id', 'touch')
+        super().__init__(*args, **kwargs)
+        self.profile = ['pos']
+
+    def depack(self, args):
+        self.sx = args['x']
+        self.sy = args['y']
+        super().depack(args)
+
+
+def async_run(func=None, app_cls_func=None):
+    def inner_func(func):
+        if 'mock' == cgl_get_backend_name():
+            return pytest.mark.skip(
+                reason='Skipping because gl backend is set to mock')(func)
+
+        if sys.version_info[0] < 3 or sys.version_info[1] <= 5:
+            return pytest.mark.skip(
+                reason='Skipping because graphics tests are not supported on '
+                       'py3.5, only on py3.6+')(func)
+
+        if app_cls_func is not None:
+            func = pytest.mark.parametrize(
+                "kivy_app", [[app_cls_func], ], indirect=True)(func)
+
+        if kivy_eventloop == 'asyncio':
+            try:
+                import pytest_asyncio
+                return pytest.mark.asyncio(func)
+            except ImportError:
+                return pytest.mark.skip(
+                    reason='KIVY_EVENTLOOP == "asyncio" but '
+                           '"pytest-asyncio" is not installed')(func)
+        elif kivy_eventloop == 'trio':
+            try:
+                import trio
+                from pytest_trio import trio_fixture
+                func._force_trio_fixture = True
+                return func
+            except ImportError:
+                return pytest.mark.skip(
+                    reason='KIVY_EVENTLOOP == "trio" but '
+                           '"pytest-trio" is not installed')(func)
+        else:
+            return pytest.mark.skip(
+                reason='KIVY_EVENTLOOP must be set to either of "asyncio" or '
+                       '"trio" to run async tests')(func)
+
+    if func is None:
+        return inner_func
+
+    return inner_func(func)
diff --git a/kivy/tests/conftest.py b/kivy/tests/conftest.py
new file mode 100644
index 0000000..5379dc3
--- /dev/null
+++ b/kivy/tests/conftest.py
@@ -0,0 +1,33 @@
+import pytest
+import os
+
+kivy_eventloop = os.environ.get('KIVY_EVENTLOOP', 'asyncio')
+
+try:
+    from .fixtures import kivy_app, kivy_clock, kivy_metrics, \
+        kivy_exception_manager
+except SyntaxError:
+    # async app tests would be skipped due to async_run forcing it to skip so
+    # it's ok to fail here as it won't be used anyway
+    pass
+
+if kivy_eventloop != 'trio':
+    @pytest.fixture()
+    def nursery():
+        pass
+
+
+def pytest_runtest_makereport(item, call):
+    # from https://docs.pytest.org/en/latest/example/simple.html
+    if "incremental" in item.keywords:
+        if call.excinfo is not None:
+            parent = item.parent
+            parent._previousfailed = item
+
+
+def pytest_runtest_setup(item):
+    # from https://docs.pytest.org/en/latest/example/simple.html
+    if "incremental" in item.keywords:
+        previousfailed = getattr(item.parent, "_previousfailed", None)
+        if previousfailed is not None:
+            pytest.xfail("previous test failed (%s)" % previousfailed.name)
diff --git a/kivy/tests/coverage_lang.kv b/kivy/tests/coverage_lang.kv
new file mode 100644
index 0000000..61b8a24
--- /dev/null
+++ b/kivy/tests/coverage_lang.kv
@@ -0,0 +1,17 @@
+#:import kivy kivy
+
+<SomeWidget@Widget>:
+    on_x: self.something = 42
+    height: self.width
+    width: 78
+    on_y:
+        self.another = 23
+        self.home = 78
+    canvas.before:
+        Color:
+            rgb: 1, 1, 1
+
+Widget:
+    size: 55, self.y + 10
+    SomeWidget:
+        size_hint_x: .5
diff --git a/kivy/tests/data/test.ini b/kivy/tests/data/test.ini
new file mode 100644
index 0000000..877008f
--- /dev/null
+++ b/kivy/tests/data/test.ini
@@ -0,0 +1,2 @@
+[section]
+key=value
diff --git a/kivy/tests/fixtures.py b/kivy/tests/fixtures.py
new file mode 100644
index 0000000..7497f4a
--- /dev/null
+++ b/kivy/tests/fixtures.py
@@ -0,0 +1,169 @@
+import pytest
+import gc
+import weakref
+import time
+import os.path
+
+__all__ = ('kivy_clock', 'kivy_metrics', 'kivy_exception_manager', 'kivy_app')
+
+
+@pytest.fixture()
+def kivy_clock():
+    from kivy.context import Context
+    from kivy.clock import ClockBase
+
+    context = Context(init=False)
+    context['Clock'] = ClockBase()
+    context.push()
+
+    from kivy.clock import Clock
+    Clock._max_fps = 0
+
+    try:
+        Clock.start_clock()
+        yield Clock
+        Clock.stop_clock()
+    finally:
+        context.pop()
+
+
+@pytest.fixture()
+def kivy_metrics():
+    from kivy.context import Context
+    from kivy.metrics import MetricsBase, Metrics
+    from kivy._metrics import dispatch_pixel_scale
+
+    context = Context(init=False)
+    context['Metrics'] = MetricsBase()
+    context.push()
+    # need to do it to reset the global value
+    dispatch_pixel_scale()
+
+    try:
+        yield Metrics
+    finally:
+        context.pop()
+        Metrics._set_cached_scaling()
+
+
+@pytest.fixture()
+def kivy_exception_manager():
+    from kivy.context import Context
+    from kivy.base import ExceptionManagerBase, ExceptionManager
+
+    context = Context(init=False)
+    context['ExceptionManager'] = ExceptionManagerBase()
+    context.push()
+
+    try:
+        yield ExceptionManager
+    finally:
+        context.pop()
+
+
+# keep track of all the kivy app fixtures so that we can check that it
+# properly dies
+apps = []
+
+
+@pytest.fixture()
+async def kivy_app(request, nursery):
+    gc.collect()
+    if apps:
+        last_app, last_request = apps.pop()
+        assert last_app() is None, \
+            'Memory leak: failed to release app for test ' + repr(last_request)
+
+    from os import environ
+    environ['KIVY_USE_DEFAULTCONFIG'] = '1'
+
+    # force window size + remove all inputs
+    from kivy.config import Config
+    Config.set('graphics', 'width', '320')
+    Config.set('graphics', 'height', '240')
+    for items in Config.items('input'):
+        Config.remove_option('input', items[0])
+
+    from kivy.core.window import Window
+    from kivy.context import Context
+    from kivy.clock import ClockBase
+    from kivy.factory import FactoryBase, Factory
+    from kivy.app import App
+    from kivy.lang.builder import BuilderBase, Builder
+    from kivy.base import stopTouchApp
+    from kivy import kivy_data_dir
+    from kivy.logger import LoggerHistory
+
+    kivy_eventloop = environ.get('KIVY_EVENTLOOP', 'asyncio')
+    if kivy_eventloop == 'asyncio':
+        pytest.importorskip(
+            'pytest_asyncio',
+            reason='KIVY_EVENTLOOP == "asyncio" but '
+                   '"pytest_asyncio" is not installed')
+        async_lib = 'asyncio'
+    elif kivy_eventloop == 'trio':
+        pytest.importorskip(
+            'pytest_trio',
+            reason='KIVY_EVENTLOOP == "trio" but '
+                   '"pytest_trio" is not installed')
+        async_lib = 'trio'
+    else:
+        pytest.skip(
+            'KIVY_EVENTLOOP must be set to either of "asyncio" or '
+            '"trio" to run async tests')
+
+    context = Context(init=False)
+    context['Clock'] = ClockBase(async_lib=async_lib)
+
+    # have to make sure all global kv files are loaded before this because
+    # globally read kv files (e.g. on module import) will not be loaded again
+    # in the new builder, except if manually loaded, which we don't do
+    context['Factory'] = FactoryBase.create_from(Factory)
+    context['Builder'] = BuilderBase.create_from(Builder)
+    context.push()
+
+    Window.create_window()
+    Window.register()
+    Window.initialized = True
+    Window.canvas.clear()
+
+    app = request.param[0]()
+    app.set_async_lib(async_lib)
+
+    if async_lib == 'asyncio':
+        import asyncio
+        loop = asyncio.get_event_loop()
+        loop.create_task(app.async_run())
+    else:
+        nursery.start_soon(app.async_run)
+    from kivy.clock import Clock
+    Clock._max_fps = 0
+
+    ts = time.perf_counter()
+    while not app.app_has_started:
+        await app.async_sleep(.1)
+        if time.perf_counter() - ts >= 10:
+            raise TimeoutError()
+
+    await app.wait_clock_frames(5)
+
+    yield app
+
+    stopTouchApp()
+
+    ts = time.perf_counter()
+    while not app.app_has_stopped:
+        await app.async_sleep(.1)
+        if time.perf_counter() - ts >= 10:
+            raise TimeoutError()
+
+    for child in Window.children[:]:
+        Window.remove_widget(child)
+    context.pop()
+
+    # release all the resources
+    del context
+    LoggerHistory.clear_history()
+    apps.append((weakref.ref(app), request))
+    del app
+    gc.collect()
diff --git a/kivy/tests/perf_test_textinput.py b/kivy/tests/perf_test_textinput.py
new file mode 100644
index 0000000..2cb9a45
--- /dev/null
+++ b/kivy/tests/perf_test_textinput.py
@@ -0,0 +1,195 @@
+from kivy.app import App
+from kivy.uix.floatlayout import FloatLayout
+from kivy.lang import Builder
+from kivy.resources import resource_find
+from kivy.clock import Clock
+
+import timeit
+
+Builder.load_string('''
+<PerfApp>:
+    value: 0
+    but: but.__self__
+    slider: slider
+    text_input: text_input
+    BoxLayout:
+        orientation: 'vertical'
+        TextInput:
+            id: text_input
+        BoxLayout:
+            orientation: 'vertical'
+            size_hint: 1, .2
+            BoxLayout:
+                Button:
+                    id: but
+                    text: 'Start Test'
+                    on_release: root.start_test() if self.text == 'Start Test'\
+                    else ''
+            Slider:
+                id: slider
+                min: 0
+                max: 100
+                value: root.value
+''')
+
+
+class PerfApp(App, FloatLayout):
+
+    def build(self):
+        return self
+
+    def __init__(self, **kwargs):
+        super(PerfApp, self).__init__(**kwargs)
+        self.tests = []
+        tests = (self.load_large_text, self.stress_insert,
+            self.stress_del, self.stress_selection)
+        for test in tests:
+            but = type(self.but)(text=test.__name__)
+            self.but.parent.add_widget(but)
+            but.test = test
+            self.tests.append(but)
+        self.test_done = True
+
+    def load_large_text(self, *largs):
+        print('loading uix/textinput.py....')
+        self.test_done = False
+        fd = open(resource_find('uix/textinput.py'), 'r')
+        print('putting text in textinput')
+
+        def load_text(*l):
+            self.text_input.text = fd.read()
+
+        t = timeit.Timer(load_text)
+        ttk = t.timeit(1)
+        fd.close()
+        import resource
+        print('mem usage after test')
+        print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024, 'MB')
+        print('------------------------------------------')
+        print('Loaded', len(self.text_input._lines), 'lines', ttk, 'secs')
+        print('------------------------------------------')
+        self.test_done = True
+
+    def stress_del(self, *largs):
+        self.test_done = False
+        text_input = self.text_input
+        self.lt = len_text = len(text_input.text)
+        target = len_text - (210 * 9)
+        self.tot_time = 0
+        ev = None
+
+        def dlt(*l):
+            if len(text_input.text) <= target:
+                ev.cancel()
+                print('Done!')
+                m_len = len(text_input._lines)
+                print('deleted 210 characters 9 times')
+                import resource
+                print('mem usage after test')
+                print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss /
+                    1024, 'MB')
+                print('total lines in text input:', m_len)
+                print('--------------------------------------')
+                print('total time elapsed:', self.tot_time)
+                print('--------------------------------------')
+                self.test_done = True
+                return
+            text_input.select_text(self.lt - 220, self.lt - 10)
+            text_input.delete_selection()
+            self.lt -= 210
+            text_input.scroll_y -= 100
+            self.tot_time += l[0]
+            ev()
+        ev = Clock.create_trigger(dlt)
+        ev()
+
+    def stress_insert(self, *largs):
+        self.test_done = False
+        text_input = self.text_input
+        text_input.select_all()
+        text_input.copy(text_input.selection_text)
+        text_input.cursor = text_input.get_cursor_from_index(
+            text_input.selection_to)
+        len_text = len(text_input._lines)
+        self.tot_time = 0
+        ev = None
+
+        def pste(*l):
+            if len(text_input._lines) >= (len_text) * 9:
+                ev.cancel()
+                print('Done!')
+                m_len = len(text_input._lines)
+                print('pasted', len_text, 'lines',
+                    round((m_len - len_text) / len_text), 'times')
+                import resource
+                print('mem usage after test')
+                print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss /
+                    1024, 'MB')
+                print('total lines in text input:', m_len)
+                print('--------------------------------------')
+                print('total time elapsed:', self.tot_time)
+                print('--------------------------------------')
+                self.test_done = True
+                return
+            self.tot_time += l[0]
+            text_input.paste()
+            ev()
+        ev = Clock.create_trigger(pste)
+        ev()
+
+    def stress_selection(self, *largs):
+        self.test_done = False
+        text_input = self.text_input
+        self.tot_time = 0
+        old_selection_from = text_input.selection_from - 210
+        ev = None
+
+        def pste(*l):
+            if text_input.selection_from >= old_selection_from:
+                ev.cancel()
+                print('Done!')
+                import resource
+                print('mem usage after test')
+                print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss /
+                    1024, 'MB')
+                print('--------------------------------------')
+                print('total time elapsed:', self.tot_time)
+                print('--------------------------------------')
+                self.test_done = True
+                return
+            text_input.select_text(text_input.selection_from - 1,
+                text_input.selection_to)
+            ev()
+        ev = Clock.create_trigger(pste)
+        ev()
+
+    def start_test(self, *largs):
+        self.but.text = 'test started'
+        self.slider.max = len(self.tests)
+        ev = None
+
+        def test(*l):
+            if self.test_done:
+                try:
+                    but = self.tests[int(self.slider.value)]
+                    self.slider.value += 1
+                    but.state = 'down'
+                    print('=====================')
+                    print('Test:', but.text)
+                    print('=====================')
+                    but.test(but)
+                except IndexError:
+                    for but in self.tests:
+                        but.state = 'normal'
+                    self.but.text = 'Start Test'
+                    self.slider.value = 0
+                    print('===================')
+                    print('All Tests Completed')
+                    print('===================')
+                    ev.cancel()
+
+        ev = Clock.schedule_interval(test, 1)
+
+
+if __name__ in ('__main__', ):
+    PerfApp().run()
diff --git a/kivy/tests/pyinstaller/__pycache__/test_pyinstaller.cpython-310.pyc b/kivy/tests/pyinstaller/__pycache__/test_pyinstaller.cpython-310.pyc
new file mode 100644
index 0000000..443f750
Binary files /dev/null and b/kivy/tests/pyinstaller/__pycache__/test_pyinstaller.cpython-310.pyc differ
diff --git a/kivy/tests/pyinstaller/simple_widget/__pycache__/main.cpython-310.pyc b/kivy/tests/pyinstaller/simple_widget/__pycache__/main.cpython-310.pyc
new file mode 100644
index 0000000..1f59e03
Binary files /dev/null and b/kivy/tests/pyinstaller/simple_widget/__pycache__/main.cpython-310.pyc differ
diff --git a/kivy/tests/pyinstaller/simple_widget/main.py b/kivy/tests/pyinstaller/simple_widget/main.py
new file mode 100644
index 0000000..d3a7a76
--- /dev/null
+++ b/kivy/tests/pyinstaller/simple_widget/main.py
@@ -0,0 +1,12 @@
+
+
+from project.widget import MyWidget
+
+if __name__ == '__main__':
+    w = MyWidget()
+
+    assert w.x == w.y
+    w.y = 868
+    assert w.x == 868
+    w.y = 370
+    assert w.x == 370
diff --git a/kivy/tests/pyinstaller/simple_widget/main.spec b/kivy/tests/pyinstaller/simple_widget/main.spec
new file mode 100644
index 0000000..2435f98
--- /dev/null
+++ b/kivy/tests/pyinstaller/simple_widget/main.spec
@@ -0,0 +1,37 @@
+# -*- mode: python -*-
+
+block_cipher = None
+from kivy_deps import sdl2, glew
+from kivy.tools.packaging.pyinstaller_hooks import runtime_hooks, hookspath
+import os
+
+
+a = Analysis(['main.py'],
+             pathex=[os.environ['__KIVY_PYINSTALLER_DIR']],
+             binaries=[],
+             datas=[],
+             hiddenimports=[],
+             hookspath=[os.environ['__KIVY_PYINSTALLER_DIR']],
+             runtime_hooks=runtime_hooks(),
+             excludes=['numpy', 'ffpyplayer'],
+             win_no_prefer_redirects=False,
+             win_private_assemblies=False,
+             cipher=block_cipher)
+pyz = PYZ(a.pure, a.zipped_data,
+             cipher=block_cipher)
+exe = EXE(pyz,
+          a.scripts,
+          exclude_binaries=True,
+          name='main',
+          debug=False,
+          strip=False,
+          upx=True,
+          console=True )
+coll = COLLECT(exe,
+               a.binaries,
+               a.zipfiles,
+               a.datas,
+               *[Tree(p) for p in (sdl2.dep_bins + glew.dep_bins)],
+               strip=False,
+               upx=True,
+               name='main')
diff --git a/kivy/tests/pyinstaller/simple_widget/project/__init__.py b/kivy/tests/pyinstaller/simple_widget/project/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/kivy/tests/pyinstaller/simple_widget/project/__pycache__/__init__.cpython-310.pyc b/kivy/tests/pyinstaller/simple_widget/project/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..7e35f43
Binary files /dev/null and b/kivy/tests/pyinstaller/simple_widget/project/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/tests/pyinstaller/simple_widget/project/__pycache__/widget.cpython-310.pyc b/kivy/tests/pyinstaller/simple_widget/project/__pycache__/widget.cpython-310.pyc
new file mode 100644
index 0000000..9cd8e44
Binary files /dev/null and b/kivy/tests/pyinstaller/simple_widget/project/__pycache__/widget.cpython-310.pyc differ
diff --git a/kivy/tests/pyinstaller/simple_widget/project/widget.py b/kivy/tests/pyinstaller/simple_widget/project/widget.py
new file mode 100644
index 0000000..7d17678
--- /dev/null
+++ b/kivy/tests/pyinstaller/simple_widget/project/widget.py
@@ -0,0 +1,12 @@
+from kivy.uix.widget import Widget
+
+
+class MyWidget(Widget):
+
+    def __init__(self, **kwargs):
+        super(MyWidget, self).__init__(**kwargs)
+
+        def callback(*l):
+            self.x = self.y
+        self.fbind('y', callback)
+        callback()
diff --git a/kivy/tests/pyinstaller/test_pyinstaller.py b/kivy/tests/pyinstaller/test_pyinstaller.py
new file mode 100644
index 0000000..2a972d8
--- /dev/null
+++ b/kivy/tests/pyinstaller/test_pyinstaller.py
@@ -0,0 +1,115 @@
+import pytest
+import os
+import subprocess
+import sys
+import shutil
+
+if sys.platform != 'win32':
+    pytestmark = pytest.mark.skip(
+        "PyInstaller is currently only tested on Windows")
+else:
+    try:
+        import PyInstaller
+    except ImportError:
+        pytestmark = pytest.mark.skip("PyInstaller is not available")
+
+
+@pytest.mark.incremental
+class PyinstallerBase(object):
+
+    pinstall_path = ''
+
+    env = None
+
+    @classmethod
+    def setup_class(cls):
+        cls.env = cls.get_env()
+
+    @classmethod
+    def get_env(cls):
+        env = os.environ.copy()
+        env['__KIVY_PYINSTALLER_DIR'] = cls.pinstall_path
+
+        if 'PYTHONPATH' not in env:
+            env['PYTHONPATH'] = cls.pinstall_path
+        else:
+            env['PYTHONPATH'] = cls.pinstall_path + os.sep + env['PYTHONPATH']
+        return env
+
+    @classmethod
+    def get_run_env(cls):
+        return os.environ.copy()
+
+    def test_project(self):
+        try:
+            # check that the project works normally before packaging
+            subprocess.check_output(
+                [sys.executable or 'python',
+                 os.path.join(self.pinstall_path, 'main.py')],
+                stderr=subprocess.STDOUT, env=self.env)
+        except subprocess.CalledProcessError as e:
+            print(e.output.decode('utf8'))
+            raise
+
+    def test_packaging(self):
+        dist = os.path.join(self.pinstall_path, 'dist')
+        build = os.path.join(self.pinstall_path, 'build')
+        try:
+            # create pyinstaller package
+            subprocess.check_output(
+                [sys.executable or 'python', '-m', 'PyInstaller',
+                 os.path.join(self.pinstall_path, 'main.spec'),
+                 '--distpath', dist, '--workpath', build],
+                stderr=subprocess.STDOUT, env=self.env)
+        except subprocess.CalledProcessError as e:
+            print(e.output.decode('utf8'))
+            raise
+
+    def test_packaged_project(self):
+        try:
+            # test package
+            subprocess.check_output(
+                os.path.join(self.pinstall_path, 'dist', 'main', 'main'),
+                stderr=subprocess.STDOUT, env=self.get_run_env())
+        except subprocess.CalledProcessError as e:
+            print(e.output.decode('utf8'))
+            raise
+
+    @classmethod
+    def teardown_class(cls):
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, '__pycache__'),
+            ignore_errors=True)
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, 'build'), ignore_errors=True)
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, 'dist'), ignore_errors=True)
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, 'project', '__pycache__'),
+            ignore_errors=True)
+
+
+class TestSimpleWidget(PyinstallerBase):
+
+    pinstall_path = os.path.join(os.path.dirname(__file__), 'simple_widget')
+
+
+class TestVideoWidget(PyinstallerBase):
+
+    pinstall_path = os.path.join(os.path.dirname(__file__), 'video_widget')
+
+    @classmethod
+    def get_env(cls):
+        env = super(TestVideoWidget, cls).get_env()
+        import kivy
+        env['__KIVY_VIDEO_TEST_FNAME'] = os.path.abspath(os.path.join(
+            kivy.kivy_examples_dir, "widgets", "cityCC0.mpg"))
+        return env
+
+    @classmethod
+    def get_run_env(cls):
+        env = super(TestVideoWidget, cls).get_run_env()
+        import kivy
+        env['__KIVY_VIDEO_TEST_FNAME'] = os.path.abspath(os.path.join(
+            kivy.kivy_examples_dir, "widgets", "cityCC0.mpg"))
+        return env
diff --git a/kivy/tests/pyinstaller/video_widget/__pycache__/main.cpython-310.pyc b/kivy/tests/pyinstaller/video_widget/__pycache__/main.cpython-310.pyc
new file mode 100644
index 0000000..8091f37
Binary files /dev/null and b/kivy/tests/pyinstaller/video_widget/__pycache__/main.cpython-310.pyc differ
diff --git a/kivy/tests/pyinstaller/video_widget/main.py b/kivy/tests/pyinstaller/video_widget/main.py
new file mode 100644
index 0000000..e5a2976
--- /dev/null
+++ b/kivy/tests/pyinstaller/video_widget/main.py
@@ -0,0 +1,6 @@
+from project import VideoApp
+
+if __name__ == '__main__':
+    from kivy.core.video import Video
+    assert Video is not None
+    VideoApp().run()
diff --git a/kivy/tests/pyinstaller/video_widget/main.spec b/kivy/tests/pyinstaller/video_widget/main.spec
new file mode 100644
index 0000000..960b742
--- /dev/null
+++ b/kivy/tests/pyinstaller/video_widget/main.spec
@@ -0,0 +1,50 @@
+# -*- mode: python -*-
+
+block_cipher = None
+from kivy_deps import sdl2, glew
+from kivy.tools.packaging.pyinstaller_hooks import runtime_hooks, hookspath
+import os
+
+deps = list(sdl2.dep_bins + glew.dep_bins)
+try:
+    import ffpyplayer
+    deps.extend(ffpyplayer.dep_bins)
+except ImportError:
+    pass
+try:
+    from kivy_deps import gstreamer
+    deps.extend(gstreamer.dep_bins)
+except ImportError:
+    pass
+print('deps are: ', deps)
+
+
+a = Analysis(['main.py'],
+             pathex=[os.environ['__KIVY_PYINSTALLER_DIR']],
+             binaries=[],
+             datas=[],
+             hiddenimports=[],
+             hookspath=[os.environ['__KIVY_PYINSTALLER_DIR']],
+             runtime_hooks=runtime_hooks(),
+             excludes=['numpy',],
+             win_no_prefer_redirects=False,
+             win_private_assemblies=False,
+             cipher=block_cipher)
+pyz = PYZ(a.pure, a.zipped_data,
+             cipher=block_cipher)
+exe = EXE(pyz,
+          a.scripts,
+          exclude_binaries=True,
+          name='main',
+          debug=False,
+          strip=False,
+          upx=True,
+          console=True )
+coll = COLLECT(exe,
+               a.binaries,
+               a.zipfiles,
+               a.datas,
+               *[Tree(p) for p in deps],
+               strip=False,
+               upx=True,
+               name='main')
diff --git a/kivy/tests/pyinstaller/video_widget/project/__init__.py b/kivy/tests/pyinstaller/video_widget/project/__init__.py
new file mode 100644
index 0000000..70a05ea
--- /dev/null
+++ b/kivy/tests/pyinstaller/video_widget/project/__init__.py
@@ -0,0 +1,38 @@
+from kivy.app import App
+from kivy.uix.videoplayer import VideoPlayer
+from kivy.clock import Clock
+import os
+import time
+
+
+class VideoApp(App):
+
+    player = None
+
+    start_t = None
+
+    def build(self):
+        self.player = player = VideoPlayer(
+            source=os.environ['__KIVY_VIDEO_TEST_FNAME'], volume=0)
+
+        self.player.fbind('position', self.check_position)
+        Clock.schedule_once(self.start_player, 0)
+        Clock.schedule_interval(self.stop_player, 1)
+        return player
+
+    def start_player(self, *args):
+        self.player.state = 'play'
+        self.start_t = time.perf_counter()
+
+    def check_position(self, *args):
+        if self.player.position > 0.1:
+            self.stop_player()
+
+    def stop_player(self, *args):
+        if time.perf_counter() - self.start_t > 10:
+            assert self.player.duration > 0
+            assert self.player.position > 0
+            self.stop()
+        else:
+            if self.player.position > 0 and self.player.duration > 0:
+                self.stop()
diff --git a/kivy/tests/pyinstaller/video_widget/project/__pycache__/__init__.cpython-310.pyc b/kivy/tests/pyinstaller/video_widget/project/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..af9b88a
Binary files /dev/null and b/kivy/tests/pyinstaller/video_widget/project/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/tests/sample1.ogg b/kivy/tests/sample1.ogg
new file mode 100644
index 0000000..d6e4520
Binary files /dev/null and b/kivy/tests/sample1.ogg differ
diff --git a/kivy/tests/test_animations.py b/kivy/tests/test_animations.py
new file mode 100644
index 0000000..d989a3d
--- /dev/null
+++ b/kivy/tests/test_animations.py
@@ -0,0 +1,415 @@
+'''
+Animations tests
+================
+'''
+import pytest
+
+
+@pytest.fixture(scope='module')
+def ec_cls():
+    class EventCounter:
+        def __init__(self, anim):
+            self.n_start = 0
+            self.n_progress = 0
+            self.n_complete = 0
+            anim.bind(on_start=self.on_start,
+                      on_progress=self.on_progress,
+                      on_complete=self.on_complete)
+
+        def on_start(self, anim, widget):
+            self.n_start += 1
+
+        def on_progress(self, anim, widget, progress):
+            self.n_progress += 1
+
+        def on_complete(self, anim, widget):
+            self.n_complete += 1
+
+        def assert_(self, n_start, n_progress_greater_than_zero, n_complete):
+            assert self.n_start == n_start
+            if n_progress_greater_than_zero:
+                assert self.n_progress > 0
+            else:
+                assert self.n_progress == 0
+            assert self.n_complete == n_complete
+    return EventCounter
+
+
+@pytest.fixture(autouse=True)
+def cleanup():
+    from kivy.animation import Animation
+    Animation.cancel_all(None)
+
+
+def no_animations_being_played():
+    from kivy.animation import Animation
+    return len(Animation._instances) == 0
+
+
+def sleep(t):
+    from time import time, sleep
+    from kivy.clock import Clock
+    tick = Clock.tick
+    deadline = time() + t
+    while time() < deadline:
+        sleep(.01)
+        tick()
+
+
+class TestAnimation:
+
+    def test_start_animation(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(1.5)
+        assert w.x == pytest.approx(100)
+        assert no_animations_being_played()
+
+    def test_animation_duration_0(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        assert no_animations_being_played()
+
+    def test_cancel_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a1 = Animation(x=100)
+        a2 = Animation(y=100)
+        w1 = Widget()
+        w2 = Widget()
+        a1.start(w1)
+        a1.start(w2)
+        a2.start(w1)
+        a2.start(w2)
+        assert not no_animations_being_played()
+        Animation.cancel_all(None)
+        assert no_animations_being_played()
+
+    def test_cancel_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a1 = Animation(x=100)
+        a2 = Animation(y=100)
+        w1 = Widget()
+        w2 = Widget()
+        a1.start(w1)
+        a1.start(w2)
+        a2.start(w1)
+        a2.start(w2)
+        assert not no_animations_being_played()
+        Animation.cancel_all(None, 'x', 'z')
+        assert not no_animations_being_played()
+        Animation.cancel_all(None, 'y')
+        assert no_animations_being_played()
+
+    def test_stop_animation(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        a.stop(w)
+        assert w.x != pytest.approx(100)
+        assert w.x != pytest.approx(0)
+        assert no_animations_being_played()
+
+    def test_stop_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w)
+        assert no_animations_being_played()
+
+    def test_stop_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=1)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w, 'x')
+        assert no_animations_being_played()
+
+    def test_duration(self):
+        from kivy.animation import Animation
+        a = Animation(x=100, d=1)
+        assert a.duration == 1
+
+    def test_transition(self):
+        from kivy.animation import Animation, AnimationTransition
+        a = Animation(x=100, t='out_bounce')
+        assert a.transition is AnimationTransition.out_bounce
+
+    def test_animated_properties(self):
+        from kivy.animation import Animation
+        a = Animation(x=100)
+        assert a.animated_properties == {'x': 100, }
+
+    def test_animated_instruction(self):
+        from kivy.graphics import Scale
+        from kivy.animation import Animation
+        a = Animation(x=100, d=1)
+        instruction = Scale(3)
+        a.start(instruction)
+        assert a.animated_properties == {'x': 100, }
+        assert instruction.x == pytest.approx(3)
+        sleep(1.5)
+        assert instruction.x == pytest.approx(100)
+        assert no_animations_being_played()
+
+    def test_weakref(self):
+        import gc
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        w = Widget()
+        a = Animation(x=100)
+        a.start(w.proxy_ref)
+        del w
+        gc.collect()
+        try:
+            sleep(1.)
+        except ReferenceError:
+            pass
+        assert no_animations_being_played()
+
+
+class TestSequence:
+
+    def test_cancel_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.cancel_all(w)
+        assert no_animations_being_played()
+
+    def test_cancel_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.cancel_all(w, 'x')
+        assert no_animations_being_played()
+
+    def test_stop_all(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w)
+        assert no_animations_being_played()
+
+    def test_stop_all_2(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        a.start(w)
+        sleep(.5)
+        Animation.stop_all(w, 'x')
+        assert no_animations_being_played()
+
+    def test_count_events(self, ec_cls):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=.5) + Animation(x=0, d=.5)
+        w = Widget()
+        ec = ec_cls(a)
+        ec1 = ec_cls(a.anim1)
+        ec2 = ec_cls(a.anim2)
+        a.start(w)
+
+        # right after the animation starts
+        ec.assert_(1, False, 0)
+        ec1.assert_(1, False, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.2)
+
+        # during the first half of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.5)
+
+        # during the second half of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 0)
+        sleep(.5)
+
+        # after the animation completed
+        ec.assert_(1, True, 1)
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 1)
+        assert no_animations_being_played()
+
+    def test_have_properties_to_animate(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        w = Widget()
+        assert not a.have_properties_to_animate(w)
+        a.start(w)
+        assert a.have_properties_to_animate(w)
+        a.stop(w)
+        assert not a.have_properties_to_animate(w)
+        assert no_animations_being_played()
+
+    def test_animated_properties(self):
+        from kivy.animation import Animation
+        a = Animation(x=100, y=200) + Animation(x=0)
+        assert a.animated_properties == {'x': 0, 'y': 200, }
+
+    def test_transition(self):
+        from kivy.animation import Animation
+        a = Animation(x=100) + Animation(x=0)
+        with pytest.raises(AttributeError):
+            a.transition
+
+
+class TestRepetitiveSequence:
+
+    def test_stop(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) + Animation(x=0)
+        a.repeat = True
+        w = Widget()
+        a.start(w)
+        a.stop(w)
+        assert no_animations_being_played()
+
+    def test_count_events(self, ec_cls):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100, d=.5) + Animation(x=0, d=.5)
+        a.repeat = True
+        w = Widget()
+        ec = ec_cls(a)
+        ec1 = ec_cls(a.anim1)
+        ec2 = ec_cls(a.anim2)
+        a.start(w)
+
+        # right after the animation starts
+        ec.assert_(1, False, 0)
+        ec1.assert_(1, False, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.2)
+
+        # during the first half of the first round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 0)
+        ec2.assert_(0, False, 0)
+        sleep(.5)
+
+        # during the second half of the first round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 0)
+        sleep(.5)
+
+        # during the first half of the second round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(2, True, 1)
+        ec2.assert_(1, True, 1)
+        sleep(.5)
+
+        # during the second half of the second round of the animation
+        ec.assert_(1, True, 0)
+        ec1.assert_(2, True, 2)
+        ec2.assert_(2, True, 1)
+        a.stop(w)
+
+        # after the animation stopped
+        ec.assert_(1, True, 1)
+        ec1.assert_(2, True, 2)
+        ec2.assert_(2, True, 2)
+        assert no_animations_being_played()
+
+
+class TestParallel:
+
+    def test_have_properties_to_animate(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) & Animation(y=100)
+        w = Widget()
+        assert not a.have_properties_to_animate(w)
+        a.start(w)
+        assert a.have_properties_to_animate(w)
+        a.stop(w)
+        assert not a.have_properties_to_animate(w)
+        assert no_animations_being_played()
+
+    def test_cancel_property(self):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) & Animation(y=100)
+        w = Widget()
+        a.start(w)
+        a.cancel_property(w, 'x')
+        assert not no_animations_being_played()
+        a.stop(w)
+        assert no_animations_being_played()
+
+    def test_animated_properties(self):
+        from kivy.animation import Animation
+        a = Animation(x=100) & Animation(y=100)
+        assert a.animated_properties == {'x': 100, 'y': 100, }
+
+    def test_transition(self):
+        from kivy.animation import Animation
+        a = Animation(x=100) & Animation(y=100)
+        with pytest.raises(AttributeError):
+            a.transition
+
+    def test_count_events(self, ec_cls):
+        from kivy.animation import Animation
+        from kivy.uix.widget import Widget
+        a = Animation(x=100) & Animation(y=100, d=.5)
+        w = Widget()
+        ec = ec_cls(a)
+        ec1 = ec_cls(a.anim1)
+        ec2 = ec_cls(a.anim2)
+        a.start(w)
+
+        # right after the animation started
+        ec.assert_(1, False, 0)
+        ec1.assert_(1, False, 0)
+        ec2.assert_(1, False, 0)
+        sleep(.2)
+
+        # during the first half of the animation
+        ec.assert_(1, False, 0)  # n_progress is still 0 !!
+        ec1.assert_(1, True, 0)
+        ec2.assert_(1, True, 0)
+        sleep(.5)
+
+        # during the second half of the animation
+        ec.assert_(1, False, 0)  # n_progress is still 0 !!
+        ec1.assert_(1, True, 0)
+        ec2.assert_(1, True, 1)
+        sleep(.5)
+
+        # after the animation compeleted
+        ec.assert_(1, False, 1)  # n_progress is still 0 !
+        ec1.assert_(1, True, 1)
+        ec2.assert_(1, True, 1)
+        assert no_animations_being_played()
diff --git a/kivy/tests/test_app.py b/kivy/tests/test_app.py
new file mode 100644
index 0000000..b834b8f
--- /dev/null
+++ b/kivy/tests/test_app.py
@@ -0,0 +1,216 @@
+from os import name
+import os.path
+from math import isclose
+from textwrap import dedent
+
+from kivy.app import App
+from kivy.clock import Clock
+from kivy import lang
+from kivy.tests import GraphicUnitTest, async_run, UnitKivyApp
+
+
+class AppTest(GraphicUnitTest):
+    def test_start_raw_app(self):
+        lang._delayed_start = None
+        a = App()
+        Clock.schedule_once(a.stop, .1)
+        a.run()
+
+    def test_start_app_with_kv(self):
+        class TestKvApp(App):
+            pass
+
+        lang._delayed_start = None
+        a = TestKvApp()
+        Clock.schedule_once(a.stop, .1)
+        a.run()
+
+    def test_user_data_dir(self):
+        a = App()
+        data_dir = a.user_data_dir
+        assert os.path.exists(data_dir)
+
+    def test_directory(self):
+        a = App()
+        assert os.path.exists(a.directory)
+
+    def test_name(self):
+        class NameTest(App):
+            pass
+
+        a = NameTest()
+        assert a.name == 'nametest'
+
+
+def basic_app():
+    from kivy.app import App
+    from kivy.uix.label import Label
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return Label(text='Hello, World!')
+
+    return TestApp()
+
+
+@async_run(app_cls_func=basic_app)
+async def test_basic_app(kivy_app):
+    assert kivy_app.root.text == 'Hello, World!'
+
+
+def button_app():
+    from kivy.app import App
+    from kivy.uix.togglebutton import ToggleButton
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return ToggleButton(text='Hello, World!')
+
+    return TestApp()
+
+
+@async_run(app_cls_func=button_app)
+async def test_button_app(kivy_app):
+    assert kivy_app.root.text == 'Hello, World!'
+    assert kivy_app.root.state == 'normal'
+
+    async for state, touch_pos in kivy_app.do_touch_down_up(
+            widget=kivy_app.root, widget_jitter=True):
+        pass
+
+    assert kivy_app.root.state == 'down'
+
+
+def scatter_app():
+    from kivy.app import App
+    from kivy.uix.label import Label
+    from kivy.uix.scatter import Scatter
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            label = Label(text='Hello, World!', size=('200dp', '200dp'))
+            scatter = Scatter(do_scale=False, do_rotation=False)
+            scatter.add_widget(label)
+            return scatter
+
+    return TestApp()
+
+
+@async_run(app_cls_func=scatter_app)
+async def test_drag_app(kivy_app):
+    scatter = kivy_app.root
+    assert tuple(scatter.pos) == (0, 0)
+
+    async for state, touch_pos in kivy_app.do_touch_drag(
+            pos=(100, 100), target_pos=(200, 200)):
+        pass
+
+    assert isclose(scatter.x, 100)
+    assert isclose(scatter.y, 100)
+
+
+def text_app():
+    from kivy.app import App
+    from kivy.uix.textinput import TextInput
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return TextInput()
+
+    return TestApp()
+
+
+@async_run(app_cls_func=text_app)
+async def test_text_app(kivy_app):
+    text = kivy_app.root
+    assert text.text == ''
+
+    # activate widget
+    async for state, touch_pos in kivy_app.do_touch_down_up(widget=text):
+        pass
+
+    async for state, value in kivy_app.do_keyboard_key(key='A', num_press=4):
+        pass
+    async for state, value in kivy_app.do_keyboard_key(key='q', num_press=3):
+        pass
+
+    assert text.text == 'AAAAqqq'
+
+
+def graphics_app():
+    from kivy.app import App
+    from kivy.uix.widget import Widget
+    from kivy.graphics import Color, Rectangle
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            widget = Widget()
+            with widget.canvas:
+                Color(1, 0, 0, 1)
+                Rectangle(pos=(0, 0), size=(100, 100))
+                Color(0, 1, 0, 1)
+                Rectangle(pos=(100, 0), size=(100, 100))
+            return widget
+
+    return TestApp()
+
+
+@async_run(app_cls_func=graphics_app)
+async def test_graphics_app(kivy_app):
+    widget = kivy_app.root
+    (r1, g1, b1, a1), (r2, g2, b2, a2) = kivy_app.get_widget_pos_pixel(
+        widget, [(50, 50), (150, 50)])
+
+    assert not g1 and not b1 and not r2 and not b2
+    assert r1 > 50 and a1 > 50 and g2 > 50 and a2 > 50
+
+
+def kv_app_ref_app():
+    from kivy.app import App
+    from kivy.lang import Builder
+    from kivy.properties import ObjectProperty
+    from kivy.uix.widget import Widget
+
+    class MyWidget(Widget):
+
+        obj = ObjectProperty(None)
+
+    Builder.load_string(dedent(
+        """
+        <MyWidget>:
+            obj: app.__self__
+        """))
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            return MyWidget()
+
+    return TestApp()
+
+
+@async_run(app_cls_func=kv_app_ref_app)
+async def test_leak_app_kv_property(kivy_app):
+    # just tests whether the app is gc'd after the test is complete
+    pass
+
+
+def kv_app_default_ref_app():
+    from kivy.app import App
+    from kivy.lang import Builder
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            # create property in kv and set app to it
+            return Builder.load_string(dedent(
+                """
+                Widget:
+                    obj: app.__self__
+                """))
+
+    return TestApp()
+
+
+@async_run(app_cls_func=kv_app_default_ref_app)
+async def test_leak_app_default_kv_property(kivy_app):
+    # just tests whether the app is gc'd after the test is complete
+    pass
diff --git a/kivy/tests/test_audio.py b/kivy/tests/test_audio.py
new file mode 100644
index 0000000..c28acbe
--- /dev/null
+++ b/kivy/tests/test_audio.py
@@ -0,0 +1,69 @@
+'''
+Audio tests
+===========
+'''
+
+import unittest
+import os
+import pytest
+if os.environ.get('KIVY_TEST_AUDIO') == '0':
+    pytestmark = pytest.mark.skip("Audio is not available")
+
+SAMPLE_FILE = os.path.join(os.path.dirname(__file__), 'sample1.ogg')
+SAMPLE_LENGTH = 1.402
+DELTA = SAMPLE_LENGTH * 0.01
+DELAY = 0.2
+
+
+class AudioTestCase(unittest.TestCase):
+
+    def get_sound(self):
+        import os
+        assert os.path.exists(SAMPLE_FILE)
+        from kivy.core import audio
+        return audio.SoundLoader.load(SAMPLE_FILE)
+
+    def test_length_simple(self):
+        sound = self.get_sound()
+        volume = sound.volume = 0.75
+        length = sound.length
+        self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+        # ensure that the gstreamer play/stop doesn't mess up the volume
+        assert volume == sound.volume
+
+    def test_length_playing(self):
+        import time
+        sound = self.get_sound()
+        sound.play()
+        try:
+            time.sleep(DELAY)
+            length = sound.length
+            self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+        finally:
+            sound.stop()
+        self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+
+    def test_length_stopped(self):
+        import time
+        sound = self.get_sound()
+        sound.play()
+        try:
+            time.sleep(DELAY)
+        finally:
+            sound.stop()
+        length = sound.length
+        self.assertAlmostEqual(SAMPLE_LENGTH, length, delta=DELTA)
+
+
+class AudioGstreamerTestCase(AudioTestCase):
+
+    def make_sound(self, source):
+        from kivy.core.audio import audio_gstreamer
+        return audio_gstreamer.SoundGstreamer(source)
+
+
+class AudioPygameTestCase(AudioTestCase):
+
+    def make_sound(self, source):
+        from kivy.core.audio import audio_pygame
+        return audio_pygame.SoundPygame(source)
diff --git a/kivy/tests/test_benchmark.py b/kivy/tests/test_benchmark.py
new file mode 100644
index 0000000..62cb83b
--- /dev/null
+++ b/kivy/tests/test_benchmark.py
@@ -0,0 +1,292 @@
+import pytest
+from string import ascii_letters
+from random import randint
+import gc
+
+import sys
+
+
+@pytest.fixture
+def kivy_benchmark(benchmark, kivy_clock):
+    from kivy.core.window import Window
+    from kivy.cache import Cache
+    from kivy.utils import platform
+    import kivy
+    from kivy.core.gl import glGetString, GL_VENDOR, GL_RENDERER, GL_VERSION
+    from kivy.context import Context
+    from kivy.clock import ClockBase
+    from kivy.factory import FactoryBase, Factory
+    from kivy.lang.builder import BuilderBase, Builder
+
+    context = Context(init=False)
+    context['Clock'] = ClockBase()
+    context['Factory'] = FactoryBase.create_from(Factory)
+    context['Builder'] = BuilderBase.create_from(Builder)
+
+    for category in list(Cache._objects.keys()):
+        if category not in Cache._categories:
+            continue
+
+        for key in list(Cache._objects[category].keys()):
+            Cache.remove(category, key)
+
+    gc.collect()
+
+    benchmark.extra_info['platform'] = str(sys.platform)
+    benchmark.extra_info['python_version'] = str(sys.version)
+    benchmark.extra_info['python_api'] = str(sys.api_version)
+    benchmark.extra_info['kivy_platform'] = platform
+    benchmark.extra_info['kivy_version'] = kivy.__version__
+    benchmark.extra_info['gl_vendor'] = str(glGetString(GL_VENDOR))
+    benchmark.extra_info['gl_renderer'] = str(glGetString(GL_RENDERER))
+    benchmark.extra_info['gl_version'] = str(glGetString(GL_VERSION))
+
+    context.push()
+    try:
+        yield benchmark
+    finally:
+        context.pop()
+
+
+def test_event_dispatcher_creation(kivy_benchmark):
+    from kivy.event import EventDispatcher
+
+    class Event(EventDispatcher):
+        pass
+    # create one just so we don't incur loading cost
+    e = Event()
+    kivy_benchmark(Event)
+
+
+def test_widget_creation(kivy_benchmark):
+    from kivy.uix.widget import Widget
+    # create one just so we don't incur loading cost
+    w = Widget()
+    kivy_benchmark(Widget)
+
+
+def test_kv_widget_creation(kivy_benchmark):
+    from kivy.lang import Builder
+    from kivy.uix.widget import Widget
+
+    class MyWidget(Widget):
+        pass
+
+    Builder.load_string("""
+<MyWidget>:
+    width: 55
+    height: 37
+    x: self.width + 5
+    y: self.height + 32
+""")
+
+    # create one just so we don't incur loading cost
+    w = MyWidget()
+    kivy_benchmark(MyWidget)
+
+
+@pytest.mark.parametrize('test_component', ['create', 'set'])
+def test_complex_kv_widget(kivy_benchmark, test_component):
+    from kivy.lang import Builder
+    from kivy.uix.widget import Widget
+
+    class MyWidget(Widget):
+        pass
+
+    Builder.load_string("""
+<MyWidget>:
+    width: 1
+    height: '{}dp'.format(self.width + 1)
+    x: self.height + 1
+    y: self.x + 1
+    size_hint_min: self.size_hint
+    size_hint_max_y: self.size_hint_min_y
+    size_hint_max_x: self.size_hint_min_x
+    opacity: sum(self.size_hint_min) + sum(self.size_hint_max)
+""")
+
+    # create one just so we don't incur loading cost
+    widget = MyWidget()
+    w = 0
+    sh = 0
+
+    def set_value():
+        nonlocal w, sh
+        w += 1
+        sh += 1
+        widget.width = w
+        widget.size_hint = sh, sh
+
+    if test_component == 'create':
+        kivy_benchmark(MyWidget)
+    else:
+        kivy_benchmark(set_value)
+
+
+def get_event_class(name, args, kwargs):
+    from kivy.event import EventDispatcher
+    import kivy.properties
+    from kivy.properties import BooleanProperty, ReferenceListProperty, \
+        AliasProperty
+
+    if name == 'AliasProperty':
+        class Event(EventDispatcher):
+            def get_a(self):
+                return 0
+
+            def set_a(self, value):
+                pass
+            a = AliasProperty(get_a, set_a)
+
+    elif name == 'ReferenceListProperty':
+        class Event(EventDispatcher):
+
+            a1 = BooleanProperty(0)
+            a2 = BooleanProperty(0)
+            a = ReferenceListProperty(a1, a2)
+
+    else:
+        cls = getattr(kivy.properties, name)
+
+        class Event(EventDispatcher):
+
+            a = cls(*args, **kwargs)
+
+    return Event
+
+
+@pytest.mark.parametrize('name,args,kwargs', [
+    ('NumericProperty', (0,), {}),
+    ('ObjectProperty', (None,), {}),
+    ('VariableListProperty', ([0, 0, 0, 0],), {}),
+    ('BoundedNumericProperty', (1, ), {'min': 0, 'max': 2}),
+    ('DictProperty', ({}, ), {}),
+    ('ColorProperty', ([1, 1, 1, 1],), {}),
+    ('BooleanProperty', (False,), {}),
+    ('OptionProperty', ('a',), {'options': ['a', 'b']}),
+    ('StringProperty', ('',), {}),
+    ('ListProperty', ([],), {}),
+    ('AliasProperty', (), {}),
+    ('ReferenceListProperty', (), {}),
+])
+def test_property_creation(kivy_benchmark, name, args, kwargs):
+    event_cls = get_event_class(name, args, kwargs)
+
+    # create one just so we don't incur loading cost
+    e = event_cls()
+    kivy_benchmark(event_cls)
+
+
+@pytest.mark.parametrize('name,args,kwargs,val,reset_val', [
+    ('NumericProperty', (0,), {}, 10, 0),
+    ('NumericProperty', (0,), {}, '10dp', 0),
+    ('NumericProperty', (0,), {}, [10, 'dp'], 0),
+    ('ObjectProperty', (None,), {}, 5, 0),
+    ('VariableListProperty', ([0, 0, 0, 0],), {}, [2, 4], [0]),
+    ('BoundedNumericProperty', (1, ), {'min': 0, 'max': 2}, .5, 1),
+    ('DictProperty', ({}, ), {}, {'name': 1}, {}),
+    ('ColorProperty', ([1, 1, 1, 1],), {}, 'red', [1, 1, 1, 1]),
+    ('BooleanProperty', (False,), {}, True, False),
+    ('OptionProperty', ('a',), {'options': ['a', 'b']}, 'b', 'a'),
+    ('StringProperty', ('',), {}, 'a', ''),
+    ('ListProperty', ([],), {}, [1, 2], []),
+    ('AliasProperty', (0,), {}, 1, 0),
+    ('ReferenceListProperty', ((1, 2),), {}, (3, 4), (1, 2)),
+])
+@pytest.mark.parametrize('exclude_first', [True, False])
+def test_property_set(
+        kivy_benchmark, name, args, kwargs, val, reset_val, exclude_first):
+    event_cls = get_event_class(name, args, kwargs)
+
+    # create one just so we don't incur loading cost
+    e = event_cls()
+
+    def set_property():
+        e.a = reset_val
+        e.a = val
+
+    if exclude_first:
+        set_property()
+    kivy_benchmark(set_property)
+
+
+@pytest.mark.parametrize('n', [1, 10, 100, 1_000])
+def test_widget_empty_draw(kivy_benchmark, n):
+    from kivy.graphics import RenderContext
+    from kivy.uix.widget import Widget
+    ctx = RenderContext()
+    root = Widget()
+    for x in range(n):
+        root.add_widget(Widget())
+    ctx.add(root.canvas)
+
+    kivy_benchmark(ctx.draw)
+
+
+@pytest.mark.parametrize('n', [1, 10, 100, 1_000])
+def test_widget_dispatch_touch(kivy_benchmark, n):
+    from kivy.tests.common import UnitTestTouch
+    from kivy.uix.widget import Widget
+
+    root = Widget()
+    for x in range(10):
+        parent = Widget()
+        for y in range(n):
+            parent.add_widget(Widget())
+        root.add_widget(parent)
+
+    touch = UnitTestTouch(10, 10)
+
+    def dispatch():
+        root.dispatch('on_touch_down', touch)
+        root.dispatch('on_touch_move', touch)
+        root.dispatch('on_touch_up', touch)
+
+    kivy_benchmark(dispatch)
+
+
+@pytest.mark.parametrize('n', [1, 10, 100, 1_000])
+@pytest.mark.parametrize('name', ['label', 'button'])
+@pytest.mark.parametrize('tick', ['tick', 'no_tick'])
+def test_random_label_create(kivy_benchmark, n, name, tick):
+    from kivy.clock import Clock
+    from kivy.uix.label import Label
+    from kivy.uix.button import Button
+    label = Label(text='*&^%')
+    button = Button(text='*&^%')
+    cls = Label if name == 'label' else Button
+
+    labels = []
+    k = len(ascii_letters)
+    for x in range(n):
+        label = [ascii_letters[randint(0, k - 1)] for _ in range(10)]
+        labels.append(''.join(label))
+
+    def make_labels():
+        o = []
+        for text in labels:
+            o.append(cls(text=text))
+
+        if tick == 'tick':
+            Clock.tick()
+    kivy_benchmark(make_labels)
+
+
+def test_parse_kv(kivy_benchmark):
+    from kivy.lang import Builder
+    suffix = 0
+
+    def parse_kv():
+        nonlocal suffix
+        Builder.load_string(f"""
+<MyWidget{suffix}>:
+    width: 55
+    height: 37
+    x: self.width + 5
+    y: self.height + 32
+""")
+        suffix += 1
+
+    # create one just so we don't incur loading cost
+    parse_kv()
+    kivy_benchmark(parse_kv)
diff --git a/kivy/tests/test_button.png b/kivy/tests/test_button.png
new file mode 100644
index 0000000..692865a
Binary files /dev/null and b/kivy/tests/test_button.png differ
diff --git a/kivy/tests/test_clipboard.py b/kivy/tests/test_clipboard.py
new file mode 100644
index 0000000..6cd140e
--- /dev/null
+++ b/kivy/tests/test_clipboard.py
@@ -0,0 +1,42 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class ClipboardTestCase(GraphicUnitTest):
+
+    def setUp(self):
+        from kivy.core.clipboard import Clipboard
+        self._clippy = Clipboard
+        clippy_types = Clipboard.get_types()
+        cliptype = clippy_types[0]
+        if 'UTF8_STRING' in clippy_types:
+            cliptype = 'UTF8_STRING'
+        self._cliptype = cliptype
+        super(ClipboardTestCase, self).setUp()
+
+    def test_clipboard_not_dummy(self):
+        clippy = self._clippy
+        if clippy.__class__.__name__ == 'ClipboardDummy':
+            self.fail('Something went wrong "dummy" clipboard is being used')
+
+    def test_clipboard_paste(self):
+        clippy = self._clippy
+        try:
+            clippy.paste()
+        except:
+            self.fail(
+                'Can not get data from clipboard')
+
+    def test_clipboard_copy(self):
+        clippy = self._clippy
+        try:
+            clippy.copy(u"Hello World")
+        except:
+            self.fail(
+                'Can not get put data to clipboard')
+
+    def test_clipboard_copy_paste(self):
+        clippy = self._clippy
+        txt1 = u"Hello 1"
+        clippy.copy(txt1)
+        ret = clippy.paste()
+        self.assertEqual(txt1, ret)
diff --git a/kivy/tests/test_clock.py b/kivy/tests/test_clock.py
new file mode 100644
index 0000000..85dfd38
--- /dev/null
+++ b/kivy/tests/test_clock.py
@@ -0,0 +1,292 @@
+'''
+Clock tests
+===========
+'''
+import gc
+import weakref
+import pytest
+
+
+class ClockCounter:
+
+    counter = 0
+
+    def __call__(self, *args, **kwargs):
+        self.counter += 1
+
+
+@pytest.fixture()
+def clock_counter():
+    yield ClockCounter()
+
+
+def test_schedule_once(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_schedule_once_twice(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 2
+
+
+def test_schedule_once_draw_after(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, 0)
+    kivy_clock.tick_draw()
+    assert clock_counter.counter == 0
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_schedule_once_draw_before(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, -1)
+    kivy_clock.tick_draw()
+    assert clock_counter.counter == 1
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_unschedule(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.unschedule(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_unschedule_event(kivy_clock, clock_counter):
+    ev = kivy_clock.schedule_once(clock_counter)
+    kivy_clock.unschedule(ev)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_unschedule_after_tick(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, 5.)
+    kivy_clock.tick()
+    kivy_clock.unschedule(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_unschedule_draw(kivy_clock, clock_counter):
+    kivy_clock.schedule_once(clock_counter, 0)
+    kivy_clock.tick_draw()
+    assert clock_counter.counter == 0
+    kivy_clock.unschedule(clock_counter)
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_trigger_create(kivy_clock, clock_counter):
+    trigger = kivy_clock.create_trigger(clock_counter, 0)
+    trigger()
+    assert clock_counter.counter == 0
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_trigger_cancel(kivy_clock, clock_counter):
+    trigger = kivy_clock.create_trigger(clock_counter, 5.)
+    trigger()
+    trigger.cancel()
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_trigger_interval(kivy_clock, clock_counter):
+    trigger = kivy_clock.create_trigger(clock_counter, 0, interval=True)
+    trigger()
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+    kivy_clock.tick()
+    assert clock_counter.counter == 2
+
+
+def test_trigger_decorator(kivy_clock, clock_counter):
+    from kivy.clock import triggered
+
+    @triggered()
+    def triggered_callback():
+        clock_counter(dt=0)
+
+    triggered_callback()
+    assert clock_counter.counter == 0
+    kivy_clock.tick()
+    assert clock_counter.counter == 1
+
+
+def test_trigger_decorator_cancel(kivy_clock, clock_counter):
+    from kivy.clock import triggered
+
+    @triggered()
+    def triggered_callback():
+        clock_counter(dt=0)
+
+    triggered_callback()
+    triggered_callback.cancel()
+    kivy_clock.tick()
+    assert clock_counter.counter == 0
+
+
+def test_exception_caught(kivy_clock, clock_counter):
+    exception = None
+
+    def handle_test_exception(e):
+        nonlocal exception
+        exception = str(e)
+
+    # monkey patch to ignore exception
+    kivy_clock.handle_exception = handle_test_exception
+
+    def raise_exception(*args):
+        raise ValueError('Stooooop')
+
+    kivy_clock.schedule_once(raise_exception)
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+
+    assert clock_counter.counter == 1
+    assert exception == 'Stooooop'
+
+
+def test_exception_ignored(kivy_clock, clock_counter):
+    def raise_exception(*args):
+        raise ValueError('Stooooop')
+
+    kivy_clock.schedule_once(raise_exception)
+    kivy_clock.schedule_once(clock_counter)
+
+    with pytest.raises(ValueError):
+        kivy_clock.tick()
+
+    assert clock_counter.counter == 0
+
+
+def test_exception_caught_handler(
+        kivy_clock, clock_counter, kivy_exception_manager):
+    from kivy.base import ExceptionHandler
+    exception = None
+
+    class KivyHandler(ExceptionHandler):
+
+        def handle_exception(self, e):
+            nonlocal exception
+            exception = str(e)
+            return kivy_exception_manager.PASS
+    kivy_exception_manager.add_handler(KivyHandler())
+
+    def raise_exception(*args):
+        raise ValueError('Stooooop')
+
+    kivy_clock.schedule_once(raise_exception)
+    kivy_clock.schedule_once(clock_counter)
+    kivy_clock.tick()
+
+    assert clock_counter.counter == 1
+    assert exception == 'Stooooop'
+
+
+def test_clock_ended_callback(kivy_clock, clock_counter):
+    counter2 = ClockCounter()
+    counter_schedule = ClockCounter()
+
+    kivy_clock.schedule_once(counter_schedule)
+    event = kivy_clock.create_lifecycle_aware_trigger(clock_counter, counter2)
+    event()
+
+    kivy_clock.stop_clock()
+    assert counter_schedule.counter == 0
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+
+def test_clock_ended_del_safe(kivy_clock, clock_counter):
+    counter2 = ClockCounter()
+    kivy_clock.schedule_lifecycle_aware_del_safe(clock_counter, counter2)
+
+    kivy_clock.stop_clock()
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+
+def test_clock_ended_raises(kivy_clock, clock_counter):
+    from kivy.clock import ClockNotRunningError
+    event = kivy_clock.create_lifecycle_aware_trigger(
+        clock_counter, clock_counter)
+
+    kivy_clock.stop_clock()
+    with pytest.raises(ClockNotRunningError):
+        event()
+    assert clock_counter.counter == 0
+
+    # we should be able to create the event
+    event = kivy_clock.create_lifecycle_aware_trigger(
+        clock_counter, clock_counter)
+    with pytest.raises(ClockNotRunningError):
+        event()
+    assert clock_counter.counter == 0
+
+    kivy_clock.schedule_once(clock_counter)
+    assert clock_counter.counter == 0
+
+
+def test_clock_ended_del_safe_raises(kivy_clock, clock_counter):
+    from kivy.clock import ClockNotRunningError
+    counter2 = ClockCounter()
+
+    kivy_clock.stop_clock()
+    with pytest.raises(ClockNotRunningError):
+        kivy_clock.schedule_lifecycle_aware_del_safe(clock_counter, counter2)
+    assert clock_counter.counter == 0
+
+
+def test_clock_stop_twice(kivy_clock, clock_counter):
+    counter2 = ClockCounter()
+    event = kivy_clock.create_lifecycle_aware_trigger(
+        clock_counter, counter2)
+    event()
+
+    kivy_clock.stop_clock()
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+    kivy_clock.stop_clock()
+    assert clock_counter.counter == 0
+    assert counter2.counter == 1
+
+
+def test_clock_restart(kivy_clock):
+    kivy_clock.stop_clock()
+    # with pytest.raises(TypeError):
+    #     kivy_clock.start_clock()
+    # for now it doesn't yet raise a error
+    kivy_clock.start_clock()
+
+
+def test_clock_event_trigger_ref(kivy_clock):
+    value = None
+
+    class Counter:
+        def call(self, *args, **kwargs):
+            nonlocal value
+            value = 42
+
+    event = kivy_clock.create_trigger(Counter().call)
+    gc.collect()
+    event()
+    kivy_clock.tick()
+    assert value is None
+
+    kivy_clock.schedule_once(Counter().call)
+    event()
+    kivy_clock.tick()
+    assert value is None
+
+    event = kivy_clock.create_trigger(Counter().call, release_ref=False)
+    gc.collect()
+    event()
+    kivy_clock.tick()
+    assert value == 42
diff --git a/kivy/tests/test_compat.py b/kivy/tests/test_compat.py
new file mode 100644
index 0000000..a75c8ae
--- /dev/null
+++ b/kivy/tests/test_compat.py
@@ -0,0 +1,6 @@
+from kivy.compat import isclose
+
+
+def test_isclose():
+    assert isclose(1.1, 1.1), 'Close floats should assert True'
+    assert not isclose(1.1, 2.1), 'Close floats should assert True'
diff --git a/kivy/tests/test_config.py b/kivy/tests/test_config.py
new file mode 100644
index 0000000..dbee514
--- /dev/null
+++ b/kivy/tests/test_config.py
@@ -0,0 +1,35 @@
+"""This module houses test for the kivy config module."""
+from kivy.config import ConfigParser
+from os.path import join, dirname
+
+SAMPLE_CONFIG = join(dirname(__file__), 'data', 'test.ini')
+
+
+def test_configparser_callbacks():
+    """Test that the ConfigParser handles callbacks."""
+    def callback():
+        pass
+
+    config = ConfigParser()
+    assert len(config._callbacks) == 0
+
+    config.add_callback(callback, 'section', 'key')
+    assert len(config._callbacks) == 1
+
+    config.remove_callback(callback, 'section', 'key')
+    assert len(config._callbacks) == 0
+
+
+def test_configparser_read():
+    """Test that the ConfigParser can read a config file."""
+    config = ConfigParser()
+    config.read(SAMPLE_CONFIG)
+    assert config.get('section', 'key') == 'value'
+
+
+def test_configparser_setdefaults():
+    """Test the setdefaults method works as expected."""
+    config = ConfigParser()
+    config.setdefaults('section', {'test': '1'})
+
+    assert config.get('section', 'test') == '1'
diff --git a/kivy/tests/test_coverage.py b/kivy/tests/test_coverage.py
new file mode 100644
index 0000000..f69ac54
--- /dev/null
+++ b/kivy/tests/test_coverage.py
@@ -0,0 +1,83 @@
+import pytest
+import os
+try:
+    import coverage
+except ImportError:
+    pytestmark = pytest.mark.skip("coverage not available")
+
+
+kv_statement_lines = {4, 5, 6, 8, 9, 12, 15, 17}
+
+
+def test_coverage_base():
+    from kivy.lang.builder import Builder
+    cov = coverage.Coverage(source=[os.path.dirname(__file__)])
+    cov.start()
+
+    fname = os.path.join(os.path.dirname(__file__), 'coverage_lang.kv')
+    try:
+        widget = Builder.load_file(fname)
+    finally:
+        cov.stop()
+
+    Builder.unload_file(fname)
+    _, statements, missing, _ = cov.analysis(fname)
+    assert set(statements) == kv_statement_lines
+    assert set(missing) == {4, 8, 9}
+
+
+def test_coverage_multiline_on_event():
+    from kivy.lang.builder import Builder
+    cov = coverage.Coverage(source=[os.path.dirname(__file__)])
+    cov.start()
+
+    fname = os.path.join(os.path.dirname(__file__), 'coverage_lang.kv')
+    try:
+        widget = Builder.load_file(fname)
+        widget.children[0].y = 65
+    finally:
+        cov.stop()
+
+    Builder.unload_file(fname)
+    _, statements, missing, _ = cov.analysis(fname)
+    assert set(statements) == kv_statement_lines
+    assert set(missing) == {4, }
+
+
+def test_coverage_trigger_event():
+    from kivy.lang.builder import Builder
+    cov = coverage.Coverage(source=[os.path.dirname(__file__)])
+    cov.start()
+
+    fname = os.path.join(os.path.dirname(__file__), 'coverage_lang.kv')
+    try:
+        widget = Builder.load_file(fname)
+        widget.children[0].x = 65
+        widget.children[0].width = 97
+    finally:
+        cov.stop()
+
+    Builder.unload_file(fname)
+    _, statements, missing, _ = cov.analysis(fname)
+    assert set(statements) == kv_statement_lines
+    assert set(missing) == {8, 9}
+
+
+def test_coverage_trigger_all():
+    from kivy.lang.builder import Builder
+    cov = coverage.Coverage(source=[os.path.dirname(__file__)])
+    cov.start()
+
+    fname = os.path.join(os.path.dirname(__file__), 'coverage_lang.kv')
+    try:
+        widget = Builder.load_file(fname)
+        widget.children[0].x = 65
+        widget.children[0].width = 97
+        widget.children[0].y = 65
+    finally:
+        cov.stop()
+
+    Builder.unload_file(fname)
+    _, statements, missing, _ = cov.analysis(fname)
+    assert set(statements) == kv_statement_lines
+    assert set(missing) == set()
diff --git a/kivy/tests/test_doc_gallery.py b/kivy/tests/test_doc_gallery.py
new file mode 100644
index 0000000..6291bd1
--- /dev/null
+++ b/kivy/tests/test_doc_gallery.py
@@ -0,0 +1,38 @@
+from kivy.tools.gallery import parse_docstring_info
+
+
+def test_parse_docstring_info():
+    assert 'error' in parse_docstring_info("No Docstring")
+    assert 'error' in parse_docstring_info("'''No Docstring Title'''")
+    assert 'error' in parse_docstring_info(
+                            "'''No Sentence\n======\nPeriods'''"
+                        )
+    assert 'error' in parse_docstring_info(
+        "'\nSingle Quotes\n===\n\nNo singles.'")
+
+    d = parse_docstring_info("""'''
+3D Rendering Monkey Head
+========================
+
+This example demonstrates using OpenGL to display a
+rotating monkey head. This
+includes loading a Blender OBJ file, shaders written in OpenGL's Shading
+Language (GLSL), and using scheduled callbacks.
+
+The file monkey.obj is a OBJ file output form the Blender free 3D creation
+software. The file is text, listing vertices and faces. It is loaded
+into a scene using objloader.py's ObjFile class. The file simple.glsl is
+a simple vertex and fragment shader written in GLSL.
+'''
+blah blah
+blah blah
+""")
+    assert 'error' not in d
+    assert '3D Rendering' in d['docstring'] and \
+           'This example' in d['docstring']
+    assert '3D Rendering' in d['title']
+    assert 'monkey head' in d['first_sentence']
+
+
+if __name__ == '__main__':
+    test_parse_docstring_info()
diff --git a/kivy/tests/test_environ_cli.py b/kivy/tests/test_environ_cli.py
new file mode 100644
index 0000000..410d79c
--- /dev/null
+++ b/kivy/tests/test_environ_cli.py
@@ -0,0 +1,50 @@
+# coding=utf-8
+
+from os import environ
+import shlex
+import subprocess
+import sys
+
+import pytest
+
+ENV_NAME = "KIVY_NO_ARGS"
+KIVY_ENVS_TO_EXCLUDE = ("KIVY_UNITTEST", "KIVY_PACKAGING")
+
+EXPECTED_STR = "Kivy Usage"
+
+TRUTHY = {"true", "1", "yes"}
+FALSY = {"false", "0", "no", "anything-else"}
+
+SAMPLE_VALUES = {*TRUTHY, *FALSY}
+
+
+def _patch_env(*filtered_keys, **kw):
+    env = {k: v for k, v in environ.items() if k not in filtered_keys}
+    env.update(kw)
+    return env
+
+
+def _kivy_subproces_import(env):
+    return subprocess.run(
+        [sys.executable, "-c", "import kivy", "--help"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=env,
+    ).stdout.decode("utf8")
+
+
+@pytest.mark.parametrize("value", SAMPLE_VALUES)
+def test_env_exist(value):
+    env = _patch_env(*KIVY_ENVS_TO_EXCLUDE, **{ENV_NAME: value})
+    stdout = _kivy_subproces_import(env)
+
+    if value in TRUTHY:
+        assert EXPECTED_STR not in stdout
+    else:
+        assert EXPECTED_STR in stdout
+
+
+def test_env_not_exist():
+    env = _patch_env(ENV_NAME, *KIVY_ENVS_TO_EXCLUDE)
+    stdout = _kivy_subproces_import(env)
+    assert EXPECTED_STR in stdout
diff --git a/kivy/tests/test_fbo_py2py3.py b/kivy/tests/test_fbo_py2py3.py
new file mode 100644
index 0000000..c3235ec
--- /dev/null
+++ b/kivy/tests/test_fbo_py2py3.py
@@ -0,0 +1,74 @@
+import unittest
+
+from kivy.tests.common import GraphicUnitTest
+from kivy.uix.widget import Widget
+from kivy.graphics import Fbo, Color, Rectangle
+
+
+class FboTest(Widget):
+    def __init__(self, **kwargs):
+        super(FboTest, self).__init__(**kwargs)
+        self.positions = [
+            (260.0, 260.0),
+            (192.0, 192.0),
+            (96.0, 192.0),
+            (192.0, 96.0),
+            (96.0, 96.0),
+            (32.0, 192.0),
+            (192.0, 32.0),
+            (32.0, 32.0)
+        ]
+
+        self.fbo = Fbo(size=(256, 256))
+        with self.fbo:
+            Color(0.56789, 0, 0, 1)
+            Rectangle(size=(256, 64))
+            Color(0, 0.56789, 0, 1)
+            Rectangle(size=(64, 256))
+            Color(0.56789, 0, 0, .5)
+            Rectangle(pos=(64, 64), size=(192, 64))
+            Color(0, 0.56789, 0, .5)
+            Rectangle(pos=(64, 64), size=(64, 192))
+        self.fbo.draw()
+
+
+class FBOPy2Py3TestCase(GraphicUnitTest):
+    def test_fbo_get_pixel_color(self):
+        fbow = FboTest()
+        render_error = 2
+        values = [
+            # out of bounds of FBO
+            (tuple, int, (0, 0, 0, 0)),
+            # in FBO, black
+            (list, int, [0, 0, 0, 0]),
+            # Color(0, 0.56789, 0, .5)
+            (list, int, [0, 72, 0, 128]),
+            # Color(0.56789, 0, 0, .5)
+            (list, int, [72, 0, 0, 128]),
+            # overlap above 2 w/ alpha
+            (list, int, [36, 72, 0, 255]),
+            # Color(0, 0.56789, 0, 1)
+            (list, int, [0, 145, 0, 255]),
+            # Color(0.56789, 0, 0, 1)
+            (list, int, [145, 0, 0, 255]),
+            # overlap above 2 w/o alpha
+            (list, int, [0, 145, 0, 255]),
+        ]
+
+        for i, pos in enumerate(fbow.positions):
+            c = fbow.fbo.get_pixel_color(pos[0], pos[1])
+            # returned class
+            self.assertTrue(isinstance(c, values[i][0]))
+            # returned types in container
+            for v in c:
+                self.assertTrue(isinstance(v, values[i][1]))
+            # returned values
+            for j, val in enumerate(c):
+                self.assertAlmostEqual(
+                    val, values[i][2][j],
+                    delta=render_error
+                )
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/kivy/tests/test_filechooser.py b/kivy/tests/test_filechooser.py
new file mode 100644
index 0000000..9a14a8e
--- /dev/null
+++ b/kivy/tests/test_filechooser.py
@@ -0,0 +1,11 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class FileChooserTestCase(GraphicUnitTest):
+
+    def test_filechooserlistview(self):
+        from kivy.uix.filechooser import FileChooserListView
+        from os.path import expanduser
+        r = self.render
+        wid = FileChooserListView(path=expanduser('~'))
+        r(wid, 2)
diff --git a/kivy/tests/test_filechooser_unicode.py b/kivy/tests/test_filechooser_unicode.py
new file mode 100644
index 0000000..2a606bc
--- /dev/null
+++ b/kivy/tests/test_filechooser_unicode.py
@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# XXX: please be careful to only save this file with an utf-8 editor
+import unittest
+import pytest
+from kivy import platform
+unicode_char = chr
+
+
+class FileChooserUnicodeTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.skip_test = platform == 'macosx' or platform == 'ios'
+        # on mac, files ending in \uffff etc. simply are changed so don't
+        # do any tests because we cannot predict the real filenames that will
+        # be created. If it works on win and linux it also works on mac.
+        # note filechooser should still work, it's only the test that fail
+        # because we have to create file ourselves.
+        if self.skip_test:
+            return
+        import os
+        from os.path import join
+        from zipfile import ZipFile
+        basepath = os.path.dirname(__file__) + u''
+        basepathu = join(basepath, u'filechooser_files')
+        self.basepathu = basepathu
+        basepathb = os.path.dirname(__file__.encode())
+        basepathb = join(basepathb, b'filechooser_files')
+        self.assertIsInstance(basepathb, bytes)
+        self.basepathb = basepathb
+
+        # this will test creating unicode and bytes filesnames
+        ufiles = [u'कीवीtestu',
+                  u'कीवीtestu' + unicode_char(0xEEEE),
+                  u'कीवीtestu' + unicode_char(0xEEEE - 1),
+                  u'कीवीtestu' + unicode_char(0xEE)]
+        # don't use non-ascii directly because that will test source file
+        # text conversion, not path issues :)
+        bfiles = [b'\xc3\xa0\xc2\xa4\xe2\x80\xa2\xc3\xa0\xc2\xa5\xe2\x82\xac\
+        \xc3\xa0\xc2\xa4\xc2\xb5\xc3\xa0\xc2\xa5\xe2\x82\xactestb',
+        b'oor\xff\xff\xff\xff\xee\xfe\xef\x81\x8D\x99testb']
+        self.ufiles = [join(basepathu, f) for f in ufiles]
+        self.bfiles = []
+        if not os.path.isdir(basepathu):
+            os.mkdir(basepathu)
+        for f in self.ufiles:
+            open(f, 'wb').close()
+        for f in self.bfiles:
+            open(f, 'wb').close()
+
+        # existing files
+        existfiles = [u'कीवीtest', u'कीऒµà¥€test',
+                      u'कीवीtest', u'testl\ufffe',
+                      u'testl\uffff']
+        self.exitsfiles = [join(basepathu, f) for f in existfiles]
+        with ZipFile(join(basepath, u'unicode_files.zip'), 'r') as myzip:
+            myzip.extractall(path=basepathu)
+        for f in self.exitsfiles:
+            open(f, 'rb').close()
+
+    @pytest.fixture(autouse=True)
+    def set_clock(self, kivy_clock):
+        self.kivy_clock = kivy_clock
+
+    def test_filechooserlistview_unicode(self):
+        if self.skip_test:
+            return
+        from kivy.uix.filechooser import FileChooserListView
+        from kivy.clock import Clock
+        from os.path import join
+
+        wid = FileChooserListView(path=self.basepathu)
+        for i in range(1):
+            Clock.tick()
+        files = [join(self.basepathu, f) for f in wid.files]
+        for f in self.ufiles:
+            self.assertIn(f, files)
+        # we cannot test the bfiles because we'd have to know the system
+        # unicode encoding to be able to compare to returned unicode
+        for f in self.exitsfiles:
+            self.assertIn(f, files)
+
+    def tearDown(self):
+        if self.skip_test:
+            return
+        from os import remove, rmdir
+        try:
+            for f in self.ufiles:
+                remove(f)
+            for f in self.exitsfiles:
+                remove(f)
+            for f in self.bfiles:
+                remove(f)
+            rmdir(self.basepathu)
+        except:
+            pass
diff --git a/kivy/tests/test_fonts.py b/kivy/tests/test_fonts.py
new file mode 100644
index 0000000..b1b8b3f
--- /dev/null
+++ b/kivy/tests/test_fonts.py
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+import unittest
+from .common import requires_graphics
+
+
+class FontTestCase(unittest.TestCase):
+
+    def setUp(self):
+        import os
+        import tempfile
+        from os.path import join, dirname, exists
+
+        fdir = dirname(__file__)
+        self.temp_dir = join(tempfile.gettempdir(), 'kivy_test_fonts')
+
+        if not exists(self.temp_dir):
+            os.mkdir(self.temp_dir)
+
+        self.font_name = join(self.temp_dir, u'कीवी.ttf')
+        if not exists(self.font_name):
+            from zipfile import ZipFile
+            with ZipFile(join(fdir, 'unicode_font.zip'), 'r') as myzip:
+                myzip.extractall(path=self.temp_dir)
+
+        print(self.font_name)
+
+    @requires_graphics
+    def test_unicode_name(self):
+        from kivy.core.text import Label
+        lbl = Label(font_name=self.font_name)
+        lbl.refresh()
+        self.assertNotEqual(lbl.get_extents(''), None)
+
+    def tearDown(self):
+        import shutil
+        from os.path import exists
+
+        if exists(self.temp_dir):
+            try:
+                shutil.rmtree(self.temp_dir)
+            except:
+                pass
diff --git a/kivy/tests/test_graphics.py b/kivy/tests/test_graphics.py
new file mode 100644
index 0000000..7ff3ff6
--- /dev/null
+++ b/kivy/tests/test_graphics.py
@@ -0,0 +1,212 @@
+'''
+Graphics tests
+==============
+
+Testing the simple vertex instructions
+'''
+
+import sys
+import pytest
+from threading import Thread
+from kivy.tests.common import GraphicUnitTest, requires_graphics
+
+
+class VertexInstructionTest(GraphicUnitTest):
+
+    def test_circle(self):
+        from kivy.uix.widget import Widget
+        from kivy.graphics import Ellipse, Color
+        r = self.render
+
+        # basic circle
+        wid = Widget()
+        with wid.canvas:
+            Color(1, 1, 1)
+            Ellipse(pos=(100, 100), size=(100, 100))
+        r(wid)
+
+        # reduced circle
+        wid = Widget()
+        with wid.canvas:
+            Color(1, 1, 1)
+            Ellipse(pos=(100, 100), size=(100, 100), segments=10)
+        r(wid)
+
+        # moving circle
+        wid = Widget()
+        with wid.canvas:
+            Color(1, 1, 1)
+            self.e = Ellipse(pos=(100, 100), size=(100, 100))
+        self.e.pos = (10, 10)
+        r(wid)
+
+    def test_ellipse(self):
+        from kivy.uix.widget import Widget
+        from kivy.graphics import Ellipse, Color
+        r = self.render
+
+        # ellipse
+        wid = Widget()
+        with wid.canvas:
+            Color(1, 1, 1)
+            self.e = Ellipse(pos=(100, 100), size=(200, 100))
+        r(wid)
+
+    def test_point(self):
+        from kivy.uix.widget import Widget
+        from kivy.graphics import Point, Color
+        r = self.render
+
+        # 1 point
+        wid = Widget()
+        with wid.canvas:
+            Color(1, 1, 1)
+            Point(points=(10, 10))
+        r(wid)
+
+        # 25 points
+        wid = Widget()
+        with wid.canvas:
+            Color(1, 1, 1)
+            Point(points=[x * 5 for x in range(50)])
+        r(wid)
+
+    def test_point_add(self):
+        from kivy.uix.widget import Widget
+        from kivy.graphics import Point, Color
+        r = self.render
+
+        wid = Widget()
+        with wid.canvas:
+            Color(1, 1, 1)
+            p = Point(pointsize=10)
+
+        p.add_point(10, 10)
+        p.add_point(90, 10)
+        p.add_point(10, 90)
+        p.add_point(50, 50)
+        p.add_point(10, 50)
+        p.add_point(50, 10)
+
+        r(wid)
+
+
+class FBOInstructionTestCase(GraphicUnitTest):
+
+    def test_fbo_pixels(self):
+        from kivy.graphics import Fbo, ClearColor, ClearBuffers, Ellipse
+
+        fbo = Fbo(size=(512, 512))
+        with fbo:
+            ClearColor(0, 0, 0, 1)
+            ClearBuffers()
+            Ellipse(pos=(100, 100), size=(100, 100))
+        fbo.draw()
+        data = fbo.pixels
+        fbo.texture.save('results.png')
+
+
+class TransformationsTestCase(GraphicUnitTest):
+
+    def test_identity_creation(self):
+        from kivy.graphics import LoadIdentity
+        mat = LoadIdentity()
+        self.assertTrue(mat.stack)
+
+
+class CallbackInstructionTest(GraphicUnitTest):
+
+    def test_from_kv(self):
+        from textwrap import dedent
+        from kivy.lang import Builder
+
+        root = Builder.load_string(dedent("""\
+        Widget:
+            canvas:
+                Callback:
+                    callback: lambda __: setattr(self, 'callback_test', 'TEST')
+        """))
+        r = self.render
+        r(root)
+        self.assertTrue(root.callback_test == 'TEST')
+
+
+@pytest.fixture
+def widget_verify_thread(request):
+    from kivy.uix.widget import Widget
+    from kivy.config import Config
+
+    original = Config.get('graphics', 'verify_gl_main_thread')
+    Config.set('graphics', 'verify_gl_main_thread', request.param)
+
+    widget = Widget()
+    yield widget, request.param
+
+    Config.set('graphics', 'verify_gl_main_thread', original)
+
+
+@requires_graphics
+@pytest.mark.parametrize('widget_verify_thread', ['0', '1'], indirect=True)
+def test_graphics_main_thread(widget_verify_thread):
+    from kivy.graphics import Color
+
+    widget, verify_thread = widget_verify_thread
+    with widget.canvas:
+        color = Color()
+    color.rgb = .1, .2, .3
+
+
+@requires_graphics
+@pytest.mark.parametrize('widget_verify_thread', ['0', '1'], indirect=True)
+def test_create_graphics_second_thread(widget_verify_thread):
+    from kivy.graphics import Color
+    widget, verify_thread = widget_verify_thread
+    exception = None
+
+    def callback():
+        nonlocal exception
+        try:
+            with widget.canvas:
+                if verify_thread == '1':
+                    with pytest.raises(TypeError):
+                        Color()
+                else:
+                    Color()
+        except BaseException as e:
+            exception = e, sys.exc_info()[2]
+            raise
+
+    thread = Thread(target=callback)
+    thread.start()
+    thread.join()
+    if exception is not None:
+        raise exception[0].with_traceback(exception[1])
+
+
+@requires_graphics
+@pytest.mark.parametrize('widget_verify_thread', ['0', '1'], indirect=True)
+def test_change_graphics_second_thread(widget_verify_thread):
+    from kivy.graphics import Color
+    widget, verify_thread = widget_verify_thread
+    with widget.canvas:
+        color = Color()
+
+    exception = None
+
+    def callback():
+        nonlocal exception
+        try:
+            if verify_thread == '1':
+                with pytest.raises(TypeError):
+                    color.rgb = .1, .2, .3
+            else:
+                color.rgb = .1, .2, .3
+        except BaseException as e:
+            exception = e, sys.exc_info()[2]
+            raise
+
+    thread = Thread(target=callback)
+    thread.start()
+    thread.join()
+    if exception is not None:
+        raise exception[0].with_traceback(exception[1])
diff --git a/kivy/tests/test_image.py b/kivy/tests/test_image.py
new file mode 100644
index 0000000..8883be4
--- /dev/null
+++ b/kivy/tests/test_image.py
@@ -0,0 +1,74 @@
+import unittest
+import io
+import os
+import tempfile
+from kivy import setupconfig
+
+
+class ImageTestCase(unittest.TestCase):
+
+    def setUp(self):
+        from kivy.core.window import Window
+        from kivy.core.image import Image
+        import os
+        self.cls = Image
+        self.image = os.path.join(os.path.dirname(__file__), 'test_button.png')
+        print(self.image)
+        self.root = Image(self.image)
+
+    def test_keep_data(self):
+        root = self.root
+        texture = root.texture
+        self.assertEqual(root._image._data[0].data, None)
+        i1 = self.cls(self.image, keep_data=True)
+        if not i1._image._data[0].data:
+            self.fail('Image has no data even with keep_data = True')
+
+    @unittest.skip("Travis on Xenial don't have SDL_image >= 2.0.5")
+    def test_save_into_bytesio(self):
+        Image = self.cls
+
+        if setupconfig.PLATFORM == "darwin":
+            # XXX on OSX CI Builder, img_sdl2 is not used
+            # therefore the test below wont work yet with imageio only.
+            return
+
+        # load kivy logo
+        img = Image.load("data/logo/kivy-icon-512.png")
+        self.assertIsNotNone(img)
+
+        # try to save without any format
+        with self.assertRaises(Exception) as context:
+            bio = io.BytesIO()
+            img.save(bio)
+
+        # save it in png
+        bio = io.BytesIO()
+        # if False, then there is no provider
+        self.assertTrue(img.save(bio, fmt="png"))
+        pngdata = bio.read()
+        self.assertTrue(len(pngdata) > 0)
+
+        # try to save in a filename
+        try:
+            _, filename = tempfile.mkstemp(suffix=".png")
+            self.assertTrue(img.save(filename, fmt="png"))
+        finally:
+            os.unlink(filename)
+
+        # XXX Test wrote but temporary commented
+        # XXX because of the issue #6123 on OSX
+        # XXX https://github.com/kivy/kivy/issues/6123
+        # with open(filename, "rb") as fd2:
+        #     pngdatafile = fd2.read()
+        # # check the png file data is the same as bytesio
+        # self.assertTrue(pngdata == pngdatafile)
+
+        # save it in jpeg
+        bio = io.BytesIO()
+        # if False, then there is no provider
+        self.assertTrue(img.save(bio, fmt="jpg"))
+        self.assertTrue(len(bio.read()) > 0)
+
+        with tempfile.NamedTemporaryFile(suffix=".jpg") as fd:
+            self.assertTrue(img.save(fd.name))
diff --git a/kivy/tests/test_imageloader.py b/kivy/tests/test_imageloader.py
new file mode 100644
index 0000000..7157a59
--- /dev/null
+++ b/kivy/tests/test_imageloader.py
@@ -0,0 +1,485 @@
+# You need an image testsuite to run this, for information see:
+# kivy/tools/image-testsuite/README.md
+
+import os
+import re
+import sys
+import unittest
+from collections import defaultdict
+from kivy.core.image import ImageLoader
+
+DEBUG = False
+ASSETDIR = 'image-testsuite'
+LOADERS = {x.__name__: x for x in ImageLoader.loaders}
+
+if 'ImageLoaderPygame' not in LOADERS:
+    try:
+        from kivy.core.image.img_pygame import ImageLoaderPygame
+        LOADERS['ImageLoaderPygame'] = ImageLoaderPygame
+    except:
+        pass
+
+# Kivy image test protocol v0: Pixel values
+v0_PIXELS = {  # NOTE: 't' is not included here, see match_prediction()
+    'w': [0xFF, 0xFF, 0xFF], 'x': [0x00, 0x00, 0x00], 'r': [0xFF, 0x00, 0x00],
+    'g': [0x00, 0xFF, 0x00], 'b': [0x00, 0x00, 0xFF], 'y': [0xFF, 0xFF, 0x00],
+    'c': [0x00, 0xFF, 0xFF], 'p': [0xFF, 0x00, 0xFF], '0': [0x00, 0x00, 0x00],
+    '1': [0x11, 0x11, 0x11], '2': [0x22, 0x22, 0x22], '3': [0x33, 0x33, 0x33],
+    '4': [0x44, 0x44, 0x44], '5': [0x55, 0x55, 0x55], '6': [0x66, 0x66, 0x66],
+    '7': [0x77, 0x77, 0x77], '8': [0x88, 0x88, 0x88], '9': [0x99, 0x99, 0x99],
+    'A': [0xAA, 0xAA, 0xAA], 'B': [0xBB, 0xBB, 0xBB], 'C': [0xCC, 0xCC, 0xCC],
+    'D': [0xDD, 0xDD, 0xDD], 'E': [0xEE, 0xEE, 0xEE], 'F': [0xFF, 0xFF, 0xFF]}
+
+# Kivy image test protocol v0: File name
+# width x height _ pattern _ alpha _ fmtinfo _ testname _ encoder . ext
+v0_FILE_RE = re.compile(r'^v0_(\d+)x(\d+)_' r'([wxrgbycptA-F0-9]+)_'
+                        r'([0-9a-fA-F]{2})_' r'([a-zA-Z0-9-]+)_'
+                        r'([a-zA-Z0-9-]+)_' r'([a-zA-Z0-9-]+)'
+                        r'\.([a-z]+)$')
+
+
+def asset(*fn):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), *fn))
+
+
+def has_alpha(fmt):
+    return fmt in ('rgba', 'bgra', 'argb', 'abgr')
+
+
+def bytes_per_pixel(fmt):
+    if fmt in ('rgb', 'bgr'):
+        return 3
+    if fmt in ('rgba', 'bgra', 'argb', 'abgr'):
+        return 4
+    raise Exception('bytes_per_pixel: unknown format {}'.format(fmt))
+
+
+def get_pixel_alpha(pix, fmt):
+    if fmt in ('rgba', 'bgra'):
+        return pix[3]
+    elif fmt in ('abgr', 'argb'):
+        return pix[0]
+    return 0xFF
+
+
+# Converts (predicted) rgba pixels to the format claimed by image loader
+def rgba_to(pix_in, target_fmt, w, h, pitch=None):
+    if not isinstance(pix_in, (bytes, bytearray)):
+        pix_in = bytearray(pix_in)
+    assert w > 0 and h > 0, "Must specify w and h"
+    assert len(pix_in) == w * h * 4, "Invalid rgba data {}".format(pix_in)
+    assert target_fmt in ('rgba', 'bgra', 'argb', 'abgr', 'rgb', 'bgr')
+
+    if target_fmt == 'rgba':
+        return pix_in
+
+    pixels = [pix_in[i:i + 4] for i in range(0, len(pix_in), 4)]
+    if target_fmt == 'bgra':
+        return b''.join([bytes(p[:3][::-1] + p[3:]) for p in pixels])
+    elif target_fmt == 'abgr':
+        return b''.join([bytes(p[3:] + p[:3][::-1]) for p in pixels])
+    elif target_fmt == 'argb':
+        return b''.join([bytes(p[3:] + p[:3]) for p in pixels])
+
+    # rgb/bgr, default to 4 byte alignment
+    if pitch is None:
+        pitch = ((3 * w) + 3) & ~3
+    # Assume pitch 0 == unaligned
+    elif pitch == 0:
+        pitch = 3 * w
+
+    out = b''
+    padding = b'\x00' * (pitch - w * 3)
+    for row in [pix_in[i:i + w * 4] for i in range(0, len(pix_in), w * 4)]:
+        pixelrow = [row[i:i + 4] for i in range(0, len(row), 4)]
+        if target_fmt == 'rgb':
+            out += b''.join([bytes(p[:3]) for p in pixelrow])
+        elif target_fmt == 'bgr':
+            out += b''.join([bytes(p[:3][::-1]) for p in pixelrow])
+        out += padding
+    return out
+
+
+def match_prediction(pixels, fmt, fd, pitch):
+    assert len(fd['alpha']) == 2
+    assert len(fd['pattern']) > 0
+
+    bpp = bytes_per_pixel(fmt)
+    rowlen = fd['w'] * bpp
+    if pitch is None:
+        pitch = (rowlen + 3) & ~3
+    elif pitch == 0:
+        pitch = fd['w'] * bpp
+    pitchalign = pitch - rowlen
+
+    errors = []
+    fail = errors.append
+
+    if len(pixels) != pitch * fd['h']:
+        fail("Pitch error: pitch {} * {} height != {} pixelbytes"
+             .format(pitch, fd['h'], len(pixels)))
+
+    ptr = 0
+    pixnum = 0
+    for char in fd['pattern']:
+        pix = list(bytearray(pixels[ptr:ptr + bpp]))
+#        print("PIXNUM {} ptr={} bpp={} : {}".format(pixnum, ptr, bpp, pix))
+        if len(pix) != bpp:
+            fail("Want {} bytes per pixel, got {}: {}"
+                 .format(bpp, len(pix), pix))
+            break
+
+        if char == 't':
+            if get_pixel_alpha(pix, fmt) != 0:
+                fail("pixel {} nonzero 't' pixel alpha {:02X}: {}".format(
+                      pixnum, get_pixel_alpha(pix, fmt), pix))
+        else:
+            srcpix = v0_PIXELS[char] + list(bytearray.fromhex(fd['alpha']))
+            predict = rgba_to(srcpix, fmt, 1, 1, pitch=0)
+            predict = list(bytearray(predict))
+            if not predict or not pix or predict != pix:
+                fail("pixel {} {} format mismatch: want {} ({}) -- got {}"
+                     .format(pixnum, fmt, predict, char, pix))
+
+        if pitchalign and (pixnum + 1) % fd['w'] == 0:
+            check = list(bytearray(pixels[ptr + bpp:ptr + bpp + pitchalign]))
+            if check != [0] * pitchalign:
+                fail("Want {} 0x00 pitch align pixnum={}, pos={} got: {}"
+                     .format(pitchalign, pixnum, ptr + bpp, check))
+            ptr += pitchalign
+        ptr += bpp
+        pixnum += 1
+
+    if ptr != len(pixels):
+        fail("Excess data: pixnum={} ptr={} bytes={}, bpp={} pitchalign={}"
+             .format(pixnum, ptr, len(pixels), bpp, pitchalign))
+    return (len(errors) == 0, errors)
+
+
+class _TestContext(object):
+    def __init__(self, loadercls):
+        self.loadercls = loadercls
+        self._fd = None
+        self._fn = None
+        self._ok = 0
+        self._skip = 0
+        self._fail = 0
+        self._stats = defaultdict(dict)
+
+    @property
+    def stats(self):
+        return self._stats
+
+    @property
+    def results(self):
+        return (self._ok, self._skip, self._fail, self._stats)
+
+    def start(self, fn, fd):
+        assert not self._fn, "unexpected ctx.start(), already started"
+        assert isinstance(fd, dict)
+        self._fn = fn
+        self._fd = fd
+
+    def end(self, fn=None):
+        assert not fn or self._fn == fn, "unexpected ctx.end(), fn mismatch"
+        self._fn = None
+        self._fd = None
+
+    def ok(self, info):
+        assert self._fn, "unexpected ctx.ok(), fn=None"
+        self._ok += 1
+        self.dbg('PASS', info)
+        self._incstat('ok')
+        self.end(self._fn)
+
+    def skip(self, info):
+        assert self._fn, "unexpected ctx.skip(), fn=None"
+        self._skip += 1
+        self.dbg('SKIP', info)
+        self._incstat('skip')
+        self.end(self._fn)
+
+    def fail(self, info):
+        assert self._fn, "unexpected ctx.fail(), fn=None"
+        self._fail += 1
+        self.dbg('FAIL', info)
+        self._incstat('fail')
+        self.end(self._fn)
+
+    def dbg(self, msgtype, info):
+        assert self._fn, "unexpected ctx.dbg(), fn=None"
+        if DEBUG:
+            print("{} {} {}: {}"
+                  .format(self.loadercls.__name__, msgtype, self._fn, info))
+
+    def _incstat(self, s):
+        assert self._fd, "unexpected ctx._incstat(), fd=None"
+        fd = self._fd
+
+        def IS(key):
+            self._stats.setdefault(s, defaultdict(int))[key] += 1
+
+        IS('total')
+        IS('extension:{}'.format(fd['ext']))
+        IS('encoder:{}'.format(fd['encoder']))
+        IS('fmtinfo:{}'.format(fd['fmtinfo']))
+        IS('testname:{}'.format(fd['testname']))
+        IS('testname+ext:{}+{}'.format(fd['testname'], fd['ext']))
+        IS('encoder+ext:{}+{}'.format(fd['encoder'], fd['ext']))
+        IS('encoder+testname:{}+{}'.format(fd['encoder'], fd['testname']))
+        IS('fmtinfo+ext:{}+{}'.format(fd['fmtinfo'], fd['ext']))
+
+
+@unittest.skipIf(not os.path.isdir(asset(ASSETDIR)),
+                 "Need 'make image-testsuite' to run test")
+class ImageLoaderTestCase(unittest.TestCase):
+    def setUp(self):
+        self._context = None
+        self._prepare_images()
+
+    def tearDown(self):
+        if not DEBUG or not self._context:
+            return
+        ctx = self._context
+        il = ctx.loadercls.__name__
+        stats = ctx.stats
+        keys = set([k for x in stats.values() for k in x.keys()])
+        sg = stats.get
+        for k in sorted(keys):
+            ok, skip, fail = sg('ok', {}), sg('skip', {}), sg('fail', {})
+            print("REPORT {} {}: ok={}, skip={}, fail={}".format(
+                  il, k, ok.get(k, 0), skip.get(k, 0), fail.get(k, 0)))
+
+    def _prepare_images(self):
+        if hasattr(self, '_image_files'):
+            return
+        self._image_files = {}
+        for filename in os.listdir(asset(ASSETDIR)):
+            matches = v0_FILE_RE.match(filename)
+            if not matches:
+                continue
+            w, h, pat, alpha, fmtinfo, tst, encoder, ext = matches.groups()
+            self._image_files[filename] = {
+                'filename': filename,
+                'w': int(w),
+                'h': int(h),
+                'pattern': pat,
+                'alpha': alpha,
+                'fmtinfo': fmtinfo,
+                'testname': tst,
+                'encoder': encoder,
+                'ext': ext,
+                'require_alpha': 'BINARY' in tst or 'ALPHA' in tst,
+            }
+
+    def _test_imageloader(self, loadercls, extensions=None):
+        if not loadercls:
+            return
+        if not extensions:
+            extensions = loadercls.extensions()
+
+        ctx = _TestContext(loadercls)
+        self._context = ctx
+        for filename in sorted(self._image_files.keys()):
+            filedata = self._image_files[filename]
+
+            if filedata['ext'] not in extensions:
+                continue
+            try:
+                ctx.start(filename, filedata)
+                result = loadercls(asset(ASSETDIR, filename), keep_data=True)
+                if not result:
+                    raise Exception('invalid result')
+            except:
+                ctx.skip('Error loading file, result=None')
+                continue
+            self._test_image(filedata, ctx, loadercls, result)
+            ctx.end()
+
+        ok, skip, fail, stats = ctx.results
+        if fail:
+            self.fail('{}: {} passed, {} skipped, {} failed'
+                      .format(loadercls.__name__, ok, skip, fail))
+        return ctx
+
+    def _test_image(self, fd, ctx, loadercls, imgdata):
+        w, h, pixels, pitch = imgdata._data[0].get_mipmap(0)
+        fmt = imgdata._data[0].fmt
+
+        # required for FFPy memview
+        # FIXME: bytearray() for py2 compat, I can't be bothered to research
+        if not isinstance(pixels, bytes):
+            pixels = bytearray(pixels)
+
+        def debug():
+            if not DEBUG:
+                return
+            print("    format: {}x{} {}".format(w, h, fmt))
+            print("     pitch: got {}, want {}".format(pitch, want_pitch))
+            print("      want: {} in {}".format(fd['pattern'], fmt))
+            print("       got: {}".format(bytearray(pixels)))
+
+        # Assume pitch 0 = unaligned
+        want_pitch = (pitch == 0) and bytes_per_pixel(fmt) * w or pitch
+        if pitch == 0 and bytes_per_pixel(fmt) * w * h != len(pixels):
+            ctx.dbg("PITCH", "pitch=0, expected fmt={} to be "
+                             "unaligned @ ({}bpp) = {} bytes, got {}"
+                             .format(fmt, bytes_per_pixel(fmt),
+                                     bytes_per_pixel(fmt) * w * h,
+                                     len(pixels)))
+        elif pitch and want_pitch != pitch:
+            ctx.dbg("PITCH", "fmt={}, pitch={}, expected {}"
+                             .format(fmt, pitch, want_pitch))
+
+        success, msgs = match_prediction(pixels, fmt, fd, pitch)
+        if not success:
+            if not msgs:
+                ctx.fail("Unknown error")
+            elif len(msgs) == 1:
+                ctx.fail(msgs[0])
+            else:
+                for m in msgs:
+                    ctx.dbg('PREDICT', m)
+                ctx.fail('{} errors, see debug output: {}'
+                         .format(len(msgs), msgs[-1]))
+            debug()
+        elif fd['require_alpha'] and not has_alpha(fmt):
+            ctx.fail('Missing expected alpha channel')
+            debug()
+        elif fd['w'] != w:
+            ctx.fail('Width mismatch, want {} got {}'
+                     .format(fd['w'], w))
+            debug()
+        elif fd['h'] != h:
+            ctx.fail('Height mismatch, want {} got {}'
+                     .format(fd['h'], h))
+            debug()
+        elif w != 1 and h != 1:
+            ctx.fail('v0 test protocol mandates w=1 or h=1')
+            debug()
+        else:
+            ctx.ok("Passed test as {}x{} {}".format(w, h, fmt))
+        sys.stdout.flush()
+
+    def test_ImageLoaderSDL2(self):
+        loadercls = LOADERS.get('ImageLoaderSDL2')
+        # GIF format not listed as supported in sdl2 loader
+        if loadercls:
+            exts = list(loadercls.extensions()) + ['gif']
+            ctx = self._test_imageloader(loadercls, exts)
+
+    def test_ImageLoaderPIL(self):
+        loadercls = LOADERS.get('ImageLoaderPIL')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderPygame(self):
+        loadercls = LOADERS.get('ImageLoaderPygame')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderFFPy(self):
+        loadercls = LOADERS.get('ImageLoaderFFPy')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderGIF(self):
+        loadercls = LOADERS.get('ImageLoaderGIF')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderDDS(self):
+        loadercls = LOADERS.get('ImageLoaderDDS')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderTex(self):
+        loadercls = LOADERS.get('ImageLoaderTex')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_ImageLoaderImageIO(self):
+        loadercls = LOADERS.get('ImageLoaderImageIO')
+        ctx = self._test_imageloader(loadercls)
+
+    def test_missing_tests(self):
+        for loader in ImageLoader.loaders:
+            key = 'test_{}'.format(loader.__name__)
+            msg = "Missing ImageLoader test case: {}".format(key)
+            self.assertTrue(hasattr(self, key), msg)
+            self.assertTrue(callable(getattr(self, key)), msg)
+
+
+class ConverterTestCase(unittest.TestCase):
+    def test_internal_converter_2x1(self):
+        correct = {
+            'rgba': b'\x01\x02\x03\xA1\x04\x05\x06\xA2',
+            'abgr': b'\xA1\x03\x02\x01\xA2\x06\x05\x04',
+            'bgra': b'\x03\x02\x01\xA1\x06\x05\x04\xA2',
+            'argb': b'\xA1\x01\x02\x03\xA2\x04\x05\x06',
+            'rgb': b'\x01\x02\x03\x04\x05\x06',
+            'bgr': b'\x03\x02\x01\x06\x05\x04',
+            'rgb_align4': b'\x01\x02\x03\x04\x05\x06\x00\x00',
+            'bgr_align4': b'\x03\x02\x01\x06\x05\x04\x00\x00'}
+        src = correct.get
+        rgba = src('rgba')
+        self.assertEqual(rgba_to(rgba, 'rgba', 2, 1, 0), src('rgba'))
+        self.assertEqual(rgba_to(rgba, 'abgr', 2, 1, 0), src('abgr'))
+        self.assertEqual(rgba_to(rgba, 'bgra', 2, 1, 0), src('bgra'))
+        self.assertEqual(rgba_to(rgba, 'argb', 2, 1, 0), src('argb'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 2, 1, 0), src('rgb'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 2, 1, 0), src('bgr'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 2, 1, None), src('rgb_align4'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 2, 1, None), src('bgr_align4'))
+
+    def test_internal_converter_3x1(self):
+        pad6 = b'\x00' * 6
+        correct = {
+            'rgba': b'\x01\x02\x03\xFF\x04\x05\x06\xFF\x07\x08\x09\xFF',
+            'abgr': b'\xFF\x03\x02\x01\xFF\x06\x05\x04\xFF\x09\x08\x07',
+            'bgra': b'\x03\x02\x01\xFF\x06\x05\x04\xFF\x09\x08\x07\xFF',
+            'argb': b'\xFF\x01\x02\x03\xFF\x04\x05\x06\xFF\x07\x08\x09',
+            'rgb_align2': b'\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00',
+            'bgr_align2': b'\x03\x02\x01\x06\x05\x04\x09\x08\x07\x00',
+            'rgb_align8': b'\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00' + pad6,
+            'bgr_align8': b'\x03\x02\x01\x06\x05\x04\x09\x08\x07\x00' + pad6}
+        src = correct.get
+        rgba = src('rgba')
+        self.assertEqual(rgba_to(rgba, 'bgra', 3, 1, 0), src('bgra'))
+        self.assertEqual(rgba_to(rgba, 'argb', 3, 1, 0), src('argb'))
+        self.assertEqual(rgba_to(rgba, 'abgr', 3, 1, 0), src('abgr'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 3, 1, 10), src('rgb_align2'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 3, 1, 10), src('bgr_align2'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 3, 1, 16), src('rgb_align8'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 3, 1, 16), src('bgr_align8'))
+
+    def test_internal_converter_1x3(self):
+        pad5 = b'\x00' * 5
+        correct = {
+            'rgba': b'\x01\x02\x03\xFF\x04\x05\x06\xFF\x07\x08\x09\xFF',
+            'rgb_raw': b'\x01\x02\x03\x04\x05\x06\x07\x08\x09',
+            'bgr_raw': b'\x03\x02\x01\x06\x05\x04\x09\x08\x07',
+            'rgb_align2': b'\x01\x02\x03\x00\x04\x05\x06\x00\x07\x08\x09\x00',
+            'bgr_align2': b'\x03\x02\x01\x00\x06\x05\x04\x00\x09\x08\x07\x00',
+            'rgb_align4': b'\x01\x02\x03\x00\x04\x05\x06\x00\x07\x08\x09\x00',
+            'bgr_align4': b'\x03\x02\x01\x00\x06\x05\x04\x00\x09\x08\x07\x00',
+            'rgb_align8': (b'\x01\x02\x03' + pad5 +
+                           b'\x04\x05\x06' + pad5 +
+                           b'\x07\x08\x09' + pad5),
+            'bgr_align8': (b'\x03\x02\x01' + pad5 +
+                           b'\x06\x05\x04' + pad5 +
+                           b'\x09\x08\x07' + pad5),
+        }
+        src = correct.get
+        rgba = src('rgba')
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, 4), src('rgb_align2'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, 4), src('bgr_align2'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, None), src('rgb_align4'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, None), src('bgr_align4'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, 0), src('rgb_raw'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, 0), src('bgr_raw'))
+        self.assertEqual(rgba_to(rgba, 'rgb', 1, 3, 8), src('rgb_align8'))
+        self.assertEqual(rgba_to(rgba, 'bgr', 1, 3, 8), src('bgr_align8'))
+
+
+if __name__ == '__main__':
+    accept_filter = ['ImageLoader{}'.format(x) for x in sys.argv[1:]]
+    if accept_filter:
+        LOADERS = {x: LOADERS[x] for x in accept_filter}
+
+    DEBUG = True
+    unittest.main(argv=sys.argv[:1])
diff --git a/kivy/tests/test_invalid_lang.py b/kivy/tests/test_invalid_lang.py
new file mode 100644
index 0000000..78ff43a
--- /dev/null
+++ b/kivy/tests/test_invalid_lang.py
@@ -0,0 +1,42 @@
+
+import unittest
+
+
+class InvalidLangTestCase(unittest.TestCase):
+
+    def test_invalid_childname(self):
+        from kivy.lang import Builder, ParserException
+        from kivy.factory import FactoryException
+        try:
+            Builder.load_string('''
+Widget:
+    FloatLayout:
+        size: self.parent.size
+        Button:
+            text: "text"
+            size_hint:(0.1, 0.1)
+            pos_hint:{'x':0.45, 'y':0.45}
+    thecursor.Cursor:
+            ''')
+            self.fail('Invalid children name')
+        except ParserException:
+            pass
+        except FactoryException:
+            pass
+
+    def test_invalid_childname_before(self):
+        from kivy.lang import Builder, ParserException
+        try:
+            Builder.load_string('''
+Widget:
+    thecursor.Cursor:
+    FloatLayout:
+        size: self.parent.size
+        Button:
+            text: "text"
+            size_hint:(0.1, 0.1)
+            pos_hint:{'x':0.45, 'y':0.45}
+            ''')
+            self.fail('Invalid children name')
+        except ParserException:
+            pass
diff --git a/kivy/tests/test_issues/__pycache__/test_6315.cpython-310.pyc b/kivy/tests/test_issues/__pycache__/test_6315.cpython-310.pyc
new file mode 100644
index 0000000..241aa2b
Binary files /dev/null and b/kivy/tests/test_issues/__pycache__/test_6315.cpython-310.pyc differ
diff --git a/kivy/tests/test_issues/__pycache__/test_issue_1084.cpython-310.pyc b/kivy/tests/test_issues/__pycache__/test_issue_1084.cpython-310.pyc
new file mode 100644
index 0000000..89ca026
Binary files /dev/null and b/kivy/tests/test_issues/__pycache__/test_issue_1084.cpython-310.pyc differ
diff --git a/kivy/tests/test_issues/__pycache__/test_issue_1091.cpython-310.pyc b/kivy/tests/test_issues/__pycache__/test_issue_1091.cpython-310.pyc
new file mode 100644
index 0000000..580a5f6
Binary files /dev/null and b/kivy/tests/test_issues/__pycache__/test_issue_1091.cpython-310.pyc differ
diff --git a/kivy/tests/test_issues/__pycache__/test_issue_599.cpython-310.pyc b/kivy/tests/test_issues/__pycache__/test_issue_599.cpython-310.pyc
new file mode 100644
index 0000000..9ceac5d
Binary files /dev/null and b/kivy/tests/test_issues/__pycache__/test_issue_599.cpython-310.pyc differ
diff --git a/kivy/tests/test_issues/__pycache__/test_issue_609.cpython-310.pyc b/kivy/tests/test_issues/__pycache__/test_issue_609.cpython-310.pyc
new file mode 100644
index 0000000..f6cb6fc
Binary files /dev/null and b/kivy/tests/test_issues/__pycache__/test_issue_609.cpython-310.pyc differ
diff --git a/kivy/tests/test_issues/__pycache__/test_issue_6909.cpython-310.pyc b/kivy/tests/test_issues/__pycache__/test_issue_6909.cpython-310.pyc
new file mode 100644
index 0000000..d6685d7
Binary files /dev/null and b/kivy/tests/test_issues/__pycache__/test_issue_6909.cpython-310.pyc differ
diff --git a/kivy/tests/test_issues/__pycache__/test_issue_883.cpython-310.pyc b/kivy/tests/test_issues/__pycache__/test_issue_883.cpython-310.pyc
new file mode 100644
index 0000000..f1be775
Binary files /dev/null and b/kivy/tests/test_issues/__pycache__/test_issue_883.cpython-310.pyc differ
diff --git a/kivy/tests/test_issues/test_6315.py b/kivy/tests/test_issues/test_6315.py
new file mode 100644
index 0000000..b55c320
--- /dev/null
+++ b/kivy/tests/test_issues/test_6315.py
@@ -0,0 +1,55 @@
+import unittest
+
+
+class PaddingSpacingTestCase(unittest.TestCase):
+    def test_tb_lr_stacklayout(self):
+        from kivy.uix.checkbox import CheckBox
+        a = CheckBox(allow_no_selection=False, group='check')
+        b = CheckBox(allow_no_selection=False, group='check')
+
+        a.active = True
+        self.assertTrue(a.active)
+        self.assertEqual(a.state, 'down')
+
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')
+
+        b.active = True
+        self.assertTrue(b.active)
+        self.assertEqual(b.state, 'down')
+
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+
+        a.state = 'down'
+        self.assertTrue(a.active)
+        self.assertEqual(a.state, 'down')
+
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')
+
+        b.state = 'down'
+        self.assertTrue(b.active)
+        self.assertEqual(b.state, 'down')
+
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+
+        b.state = 'normal'
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')
+
+        b.state = 'down'
+        self.assertTrue(b.active)
+        self.assertEqual(b.state, 'down')
+
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+
+        b.active = False
+        self.assertFalse(a.active)
+        self.assertEqual(a.state, 'normal')
+        self.assertFalse(b.active)
+        self.assertEqual(b.state, 'normal')
diff --git a/kivy/tests/test_issues/test_issue_1084.py b/kivy/tests/test_issues/test_issue_1084.py
new file mode 100644
index 0000000..703471c
--- /dev/null
+++ b/kivy/tests/test_issues/test_issue_1084.py
@@ -0,0 +1,47 @@
+#
+# Bug fixed:
+# - put utf-8 in string, and validate -> no more crash due to str() encoding
+# - put utf-8 in string, validate, close, open the app and edit the value -> no
+# more weird space due to ascii->utf8 encoding.
+# - create an unicode directory, and select it with Path. -> no more crash at
+# validation.
+# - create an unicode directory, and select it with Path and restart -> the
+# path is still correct.
+
+from kivy.app import App
+
+data = '''
+[
+    {
+        "type": "string",
+        "title": "String",
+        "desc": "-",
+        "section": "test",
+        "key": "string"
+    },
+    {
+        "type": "path",
+        "title": "Path",
+        "desc": "-",
+        "section": "test",
+        "key": "path"
+    }
+]
+'''
+
+
+class UnicodeIssueSetting(App):
+    def build_config(self, config):
+        config.add_section('test')
+        config.setdefault('test', 'string', 'Hello world')
+        config.setdefault('test', 'path', '/')
+
+    def build(self):
+        from kivy.uix.settings import Settings
+        s = Settings()
+        s.add_json_panel('Test Panel', self.config, data=data)
+        return s
+
+
+if __name__ == '__main__':
+    UnicodeIssueSetting().run()
diff --git a/kivy/tests/test_issues/test_issue_1091.py b/kivy/tests/test_issues/test_issue_1091.py
new file mode 100644
index 0000000..24fb61c
--- /dev/null
+++ b/kivy/tests/test_issues/test_issue_1091.py
@@ -0,0 +1,19 @@
+import unittest
+
+
+class PaddingSpacingTestCase(unittest.TestCase):
+    def test_tb_lr_stacklayout(self):
+        from kivy.uix.stacklayout import StackLayout
+        from kivy.uix.widget import Widget
+
+        stacklayout = StackLayout(
+            orientation='tb-lr',
+            size=(200, 200),
+            padding=20,
+            spacing=10)
+
+        widget = Widget(width=100, size_hint=(0.2, 0.4))
+        stacklayout.add_widget(widget)
+        stacklayout.do_layout()
+
+        self.assertEqual(stacklayout.top - widget.top, 20)
diff --git a/kivy/tests/test_issues/test_issue_599.py b/kivy/tests/test_issues/test_issue_599.py
new file mode 100644
index 0000000..e2a53a8
--- /dev/null
+++ b/kivy/tests/test_issues/test_issue_599.py
@@ -0,0 +1,21 @@
+import unittest
+
+
+class Issue599(unittest.TestCase):
+
+    def test_minmax(self):
+        from kivy.event import EventDispatcher
+        from kivy.properties import BoundedNumericProperty
+
+        class PropertyWidget(EventDispatcher):
+            foo = BoundedNumericProperty(1, min=-5, max=5)
+
+        wid = PropertyWidget()
+
+        self.assertEqual(wid.property('foo').get_min(wid), -5)
+        wid.property('foo').set_min(wid, 0)
+        self.assertEqual(wid.property('foo').get_min(wid), 0)
+
+        self.assertEqual(wid.property('foo').get_max(wid), 5)
+        wid.property('foo').set_max(wid, 10)
+        self.assertEqual(wid.property('foo').get_max(wid), 10)
diff --git a/kivy/tests/test_issues/test_issue_609.py b/kivy/tests/test_issues/test_issue_609.py
new file mode 100644
index 0000000..ccaa8c7
--- /dev/null
+++ b/kivy/tests/test_issues/test_issue_609.py
@@ -0,0 +1,19 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class Issue609(object):
+
+    def test_markup_pos(self):
+        from kivy.uix.label import Label
+        from kivy.uix.gridlayout import GridLayout
+
+        lbl = Label(text="TextToTest")
+        lbl.bind(text_size=lbl.setter('size'))
+        mrkp = Label(text="TextToTest", markup=True)
+        mrkp.bind(text_size=mrkp.setter('size'))
+
+        grid = GridLayout(rows=1, size_hint=(1, 1))
+        grid.add_widget(lbl)
+        grid.add_widget(mrkp)
+
+        self.render(grid, 2)
diff --git a/kivy/tests/test_issues/test_issue_6909.py b/kivy/tests/test_issues/test_issue_6909.py
new file mode 100644
index 0000000..6d83c59
--- /dev/null
+++ b/kivy/tests/test_issues/test_issue_6909.py
@@ -0,0 +1,28 @@
+import locale
+import unittest
+from unittest import mock
+from kivy import Config
+from kivy.logger import Logger, FileHandler
+import pytest
+
+
+class CodecLoggingTestCase(unittest.TestCase):
+    def test_log_handles_cp949(self):
+        with mock.patch("locale.getpreferredencoding", return_value="cp949"):
+            FileHandler.fd = None
+            FileHandler.encoding = "utf-8"
+            Config.set("kivy", "log_enable", 1)
+            Config.set("kivy", "log_level", "trace")
+            for string in ["한국어", "Niñas and niños"]:
+                Logger.trace("Lang: call_fn => value=%r" % (string,))
+
+    def test_non_utf8_encoding_raises_exception(
+        self,
+    ):  # the old error before utf-8 was standard
+        FileHandler.fd = None
+        FileHandler.encoding = "cp949"
+        Config.set("kivy", "log_enable", 1)
+        Config.set("kivy", "log_level", "trace")
+
+        with pytest.raises(UnicodeError):
+            Logger.trace("Lang: call_fn => value=%r" % ("Niñas and niños",))
diff --git a/kivy/tests/test_issues/test_issue_883.py b/kivy/tests/test_issues/test_issue_883.py
new file mode 100644
index 0000000..68149dd
--- /dev/null
+++ b/kivy/tests/test_issues/test_issue_883.py
@@ -0,0 +1,12 @@
+import unittest
+
+
+class LabelEmptyMarkupTestCase(unittest.TestCase):
+    def test_empty_markup(self):
+        from kivy.uix.label import Label
+
+        label = Label(text='[b][/b]', markup=True)
+        label.texture_update()
+        self.assertTrue(label.texture is not None)
+        self.assertEqual(label.texture.width, 1)
+        self.assertEqual(label.texture.height, 1)
diff --git a/kivy/tests/test_kivy_init.py b/kivy/tests/test_kivy_init.py
new file mode 100644
index 0000000..4ffed74
--- /dev/null
+++ b/kivy/tests/test_kivy_init.py
@@ -0,0 +1,30 @@
+from kivy import (
+    kivy_configure, kivy_register_post_configuration, get_includes,
+    kivy_usage)
+from unittest.mock import Mock, patch
+from os.path import exists, isdir
+
+
+def test_kivy_configure():
+    """Test the kivy_configure calls the post_configuration callbacks."""
+    mock_callback = Mock()
+    kivy_register_post_configuration(mock_callback)
+    kivy_configure()
+
+    mock_callback.assert_called()
+
+
+def test_kivy_get_includes():
+    """Test that the `get_includes` function return a list of valid paths."""
+    paths = get_includes()
+    assert len(paths) > 2, "get_includes does not return a full path list."
+    for path in paths:
+        assert exists(path) and isdir(path), \
+            "get_includes returns invalid paths."
+
+
+def test_kivy_usage():
+    """Test the kivy_usage commmand."""
+    with patch('kivy.print') as mock_print:
+        kivy_usage()
+        mock_print.assert_called()
diff --git a/kivy/tests/test_knspace.py b/kivy/tests/test_knspace.py
new file mode 100644
index 0000000..fd1fd12
--- /dev/null
+++ b/kivy/tests/test_knspace.py
@@ -0,0 +1,247 @@
+
+import unittest
+'''ACHTUNG: when testing, never re-use widget names, otherwise the tests
+may fail as the namespace will remember the names between tests.
+'''
+
+
+class KNSpaceTestCase(unittest.TestCase):
+
+    def test_not_exists(self):
+        from kivy.uix.behaviors.knspace import knspace
+        self.assertRaises(AttributeError, lambda: knspace.label)
+
+    def test_not_exists_property(self):
+        from kivy.uix.behaviors.knspace import knspace
+        self.assertRaises(AttributeError, lambda: knspace.label2)
+        knspace.property('label2')
+        self.assertIsNone(knspace.label2)
+
+    def test_allow_none(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+        knspace.label3 = 1
+        knspace.label3 = None
+        w = MyWidget()
+        w.knspace = knspace
+        w.knspace = None
+
+    def test_name(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+        w = MyWidget()
+        w.knsname = 'label4'
+        w.knsname = ''
+
+    def test_proxy_ref(self):
+        from kivy.uix.behaviors.knspace import knspace
+        from kivy.uix.widget import Widget
+
+        w = Widget()
+        knspace.widget1 = w
+        self.assertIs(w.proxy_ref, knspace.widget1)
+        knspace.widget1 = 55
+        self.assertIs(55, knspace.widget1)
+
+    def test_constructor(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+
+        w = MyWidget(knsname='construct_name')
+        self.assertEqual(knspace.construct_name, w)
+
+    def test_re_assign(self):
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class MyWidget(KNSpaceBehavior, Widget):
+            pass
+
+        w = MyWidget(knsname='construct_name2')
+        self.assertEqual(knspace.construct_name2, w)
+        w2 = MyWidget(knsname='construct_name2')
+        self.assertEqual(knspace.construct_name2, w2)
+
+    def test_simple(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+NamedLabel:
+    knsname: 'label5'
+    text: 'Hello'
+''')
+        self.assertEqual(knspace.label5, w)
+        self.assertIs(w, knspace.label5.__self__)
+        self.assertIsNot(w, knspace.label5)
+        self.assertEqual('Hello', knspace.label5.text)
+        w.text = 'Goodbye'
+        self.assertEqual('Goodbye', knspace.label5.text)
+
+    def test_simple_multiple_names(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+BoxLayout:
+    NamedLabel:
+        knsname: 'label61'
+        text: 'Hello'
+    NamedLabel:
+        knsname: 'label62'
+        text: 'Goodbye'
+''')
+        self.assertEqual('Hello', knspace.label61.text)
+        self.assertEqual('Goodbye', knspace.label62.text)
+
+    def test_simple_binding(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+#:import knspace kivy.uix.behaviors.knspace.knspace
+<NamedLabel@KNSpaceBehavior+Label>
+
+BoxLayout:
+    text: knspace.label7.text if knspace.label7 else ''
+    NamedLabel:
+        knsname: 'label7'
+        text: 'Hello'
+''')
+        self.assertEqual('Hello', w.text)
+        knspace.label7.text = 'Goodbye'
+        self.assertEqual('Goodbye', w.text)
+
+    def test_simple_name_change(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+NamedLabel:
+    knsname: 'label8'
+    text: 'Hello'
+''')
+        self.assertEqual(w, knspace.label8)
+        w.knsname = 'named_label8'
+        self.assertIsNone(knspace.label8)
+        self.assertEqual(w, knspace.named_label8)
+
+    def test_fork_string(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+BoxLayout:
+    NamedLabel:
+        knspace: 'fork'
+        knsname: 'label9'
+        text: 'Hello'
+    NamedLabel:
+        knspace: 'fork'
+        knsname: 'label9'
+        text: 'Goodbye'
+''')
+        self.assertEqual(w.children[0].knspace.label9.text, 'Goodbye')
+        self.assertEqual(w.children[1].knspace.label9.text, 'Hello')
+
+    def test_fork(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace, KNSpaceBehavior
+        from kivy.uix.widget import Widget
+
+        class NamedWidget(KNSpaceBehavior, Widget):
+            pass
+        nw = NamedWidget()
+        w = Widget()
+        w2 = Widget()
+
+        before = knspace.fork()
+        knspace.widget2 = w
+        after = knspace.fork()
+        self.assertEqual(knspace.widget2, w)
+        self.assertEqual(before.widget2, w)
+        self.assertEqual(after.widget2, w)
+
+        child = knspace.fork()
+        child2 = knspace.fork()
+        grandchild = child.fork()
+        child.widget3 = w2
+        self.assertEqual(grandchild.widget3, w2)
+        self.assertEqual(child.widget3, w2)
+        # this could actually be none rather than raising, depending
+        # on when the class was instantiated. So if this fails, change the
+        # test to assert is none.
+        self.assertIsNone(knspace.widget3)
+        grandchild.parent = child2
+        self.assertIsNone(grandchild.widget3)
+
+    def test_fork_binding(self):
+        from kivy.lang import Builder
+        from kivy.uix.behaviors.knspace import knspace
+
+        w = Builder.load_string('''
+<NamedLabel@KNSpaceBehavior+Label>
+
+<MyComplexWidget@NamedLabel>:
+    knsname: 'root_label'
+    text: 'Hello'
+    NamedLabel:
+        id: child
+        knsname: 'child_label'
+        text: self.knspace.root_label.text if self.knspace.root_label else ''
+
+BoxLayout:
+    MyComplexWidget:
+        knspace: 'fork'
+        id: first
+    MyComplexWidget:
+        knspace: 'fork'
+        id: second
+''')
+        self.assertEqual(w.ids.first.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Hello')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        w.ids.first.text = 'Goodbye'
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        first = w.ids.first.knspace
+        w.ids.first.knspace = w.ids.second.knspace
+        w.ids.second.knspace = first
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        w.ids.first.text = 'Goodbye2'
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye2')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye2')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
+
+        w.ids.first.knspace.root_label.text = 'Goodbye3'
+        self.assertEqual(w.ids.first.ids.child.text, 'Goodbye3')
+        self.assertEqual(w.ids.second.ids.child.text, 'Hello')
+        self.assertEqual(w.ids.first.knspace.child_label.text, 'Goodbye3')
+        self.assertEqual(w.ids.second.knspace.child_label.text, 'Hello')
diff --git a/kivy/tests/test_lang.py b/kivy/tests/test_lang.py
new file mode 100644
index 0000000..def7a4d
--- /dev/null
+++ b/kivy/tests/test_lang.py
@@ -0,0 +1,405 @@
+'''
+Language tests
+==============
+'''
+
+import unittest
+import os
+from weakref import proxy
+from functools import partial
+from textwrap import dedent
+
+
+class BaseClass(object):
+    uid = 0
+
+    # base class needed for builder
+    def __init__(self, **kwargs):
+        super(BaseClass, self).__init__()
+        self.proxy_ref = proxy(self)
+        self.children = []
+        self.parent = None
+        self.binded_func = {}
+        self.id = None
+        self.ids = {}
+        self.cls = []
+        self.ids = {}
+        self.uid = BaseClass.uid
+        BaseClass.uid += 1
+
+    def add_widget(self, widget):
+        self.children.append(widget)
+        widget.parent = self
+
+    def dispatch(self, event_type, *largs, **kwargs):
+        pass
+
+    def create_property(self, name, value=None, default_value=True):
+        pass
+
+    def is_event_type(self, key):
+        return key.startswith('on_')
+
+    def fbind(self, name, func, *largs):
+        self.binded_func[name] = partial(func, *largs)
+        return True
+
+    def apply_class_lang_rules(
+            self, root=None, ignored_consts=set(), rule_children=None):
+        pass
+
+
+class TLangClass(BaseClass):
+    obj = None
+
+
+class TLangClass2(BaseClass):
+    obj = None
+
+
+class TLangClass3(BaseClass):
+    obj = None
+
+
+class LangTestCase(unittest.TestCase):
+
+    def import_builder(self):
+        from kivy.factory import Factory
+        from kivy.lang import BuilderBase
+        Builder = BuilderBase()
+        Factory.register('TLangClass', cls=TLangClass)
+        Factory.register('TLangClass2', cls=TLangClass2)
+        Factory.register('TLangClass3', cls=TLangClass3)
+        return Builder
+
+    def test_loading_failed_1(self):
+        # invalid indent
+        Builder = self.import_builder()
+        from kivy.lang import ParserException
+        try:
+            Builder.load_string(dedent('''#:kivy 1.0
+            <TLangClass>:
+            '''))
+            self.fail('Invalid indentation.')
+        except ParserException:
+            pass
+
+    def test_parser_numeric_1(self):
+        Builder = self.import_builder()
+        Builder.load_string('<TLangClass>:\n\tobj: (.5, .5, .5)')
+        wid = TLangClass()
+        Builder.apply(wid)
+        self.assertEqual(wid.obj, (0.5, 0.5, 0.5))
+
+    def test_parser_numeric_2(self):
+        Builder = self.import_builder()
+        Builder.load_string('<TLangClass>:\n\tobj: (0.5, 0.5, 0.5)')
+        wid = TLangClass()
+        Builder.apply(wid)
+        self.assertEqual(wid.obj, (0.5, 0.5, 0.5))
+
+    def test_references(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        <TLangClass>:
+            textinput: textinput
+            TLangClass2:
+                id: textinput
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+
+        self.assertTrue(hasattr(wid, 'textinput'))
+        self.assertTrue(getattr(wid, 'textinput') is not None)
+
+    def test_references_with_template(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        [Item@TLangClass3]:
+            title: ctx.title
+        <TLangClass>:
+            textinput: textinput
+            Item:
+                title: 'bleh'
+            TLangClass2:
+                id: textinput
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+
+        self.assertTrue(hasattr(wid, 'textinput'))
+        self.assertTrue(getattr(wid, 'textinput') is not None)
+
+    def test_references_with_template_case_2(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        [Item@TLangClass3]:
+            title: ctx.title
+        <TLangClass>:
+            textinput: textinput
+            TLangClass2:
+                id: textinput
+                Item:
+                    title: 'bleh'
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+
+        self.assertTrue(hasattr(wid, 'textinput'))
+        self.assertTrue(getattr(wid, 'textinput') is not None)
+
+    def test_references_with_template_case_3(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        [Item@TLangClass3]:
+            title: ctx.title
+        <TLangClass>:
+            textinput: textinput
+            TLangClass2:
+                Item:
+                    title: 'bleh'
+                TLangClass2:
+                    TLangClass2:
+                        id: textinput
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+
+        self.assertTrue(hasattr(wid, 'textinput'))
+        self.assertTrue(getattr(wid, 'textinput') is not None)
+
+    def test_with_multiline(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        <TLangClass>:
+            on_press:
+                print('hello world')
+                print('this is working !')
+                self.a = 1
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+        wid.a = 0
+
+        self.assertTrue('on_press' in wid.binded_func)
+        wid.binded_func['on_press']()
+        self.assertEqual(wid.a, 1)
+
+    def test_with_eight_spaces(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        <TLangClass>:
+                on_press:
+                        print('hello world')
+                        print('this is working !')
+                        self.a = 1
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+        wid.a = 0
+
+        self.assertTrue('on_press' in wid.binded_func)
+        wid.binded_func['on_press']()
+        self.assertEqual(wid.a, 1)
+
+    def test_with_one_space(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        <TLangClass>:
+         on_press:
+          print('hello world')
+          print('this is working !')
+          self.a = 1
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+        wid.a = 0
+
+        self.assertTrue('on_press' in wid.binded_func)
+        wid.binded_func['on_press']()
+        self.assertEqual(wid.a, 1)
+
+    def test_with_two_spaces(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        <TLangClass>:
+          on_press:
+            print('hello world')
+            print('this is working !')
+            self.a = 1
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+        wid.a = 0
+
+        self.assertTrue('on_press' in wid.binded_func)
+        wid.binded_func['on_press']()
+        self.assertEqual(wid.a, 1)
+
+    def test_property_trailingspace(self):
+        Builder = self.import_builder()
+        Builder.load_string(dedent('''
+        <TLangClass>:
+            text : 'original'
+            on_press : self.text = 'changed'
+        '''))
+        wid = TLangClass()
+        Builder.apply(wid)
+
+        self.assertTrue('on_press' in wid.binded_func)
+        self.assertEqual(wid.text, 'original')
+
+        # call the on_press and check the result
+        wid.binded_func['on_press']()
+        self.assertEqual(wid.text, 'changed')
+
+    def test_kv_python_init(self):
+        from kivy.factory import Factory
+        from kivy.lang import Builder
+        from kivy.uix.widget import Widget
+
+        class MyObject(object):
+            value = 55
+
+        class MyWidget(Widget):
+            cheese = MyObject()
+
+        Builder.load_string(dedent('''
+        <MyWidget>:
+            x: 55
+            y: self.width + 10
+            height: self.cheese.value
+            width: 44
+
+        <MySecondWidget@Widget>:
+            x: 55
+            Widget:
+                x: 23
+        '''))
+
+        w = MyWidget(x=22, height=12, y=999)
+        self.assertEqual(w.x, 22)
+        self.assertEqual(w.width, 44)
+        self.assertEqual(w.y, 44 + 10)
+        self.assertEqual(w.height, 12)
+
+        w2 = Factory.MySecondWidget(x=999)
+        self.assertEqual(w2.x, 999)
+        self.assertEqual(w2.children[0].x, 23)
+
+    def test_apply_rules(self):
+        Builder = self.import_builder()
+        Builder.load_string('<TLangClassCustom>:\n\tobj: 42')
+        wid = TLangClass()
+        Builder.apply(wid)
+        self.assertIsNone(wid.obj)
+        Builder.apply_rules(wid, 'TLangClassCustom')
+        self.assertEqual(wid.obj, 42)
+
+    def test_load_utf8(self):
+        from tempfile import mkstemp
+        from kivy.lang import Builder
+        fd, name = mkstemp()
+        os.write(fd, dedent('''
+        Label:
+            text: 'é 😊'
+        ''').encode('utf8'))
+        root = Builder.load_file(name)
+        assert root.text == 'é 😊'
+        os.close(fd)
+
+    def test_bind_fstring(self):
+        from kivy.lang import Builder
+        label = Builder.load_string(dedent('''
+        <TestLabel@Label>:
+            text: f'{self.pos}|{self.size}'
+        TestLabel:
+        '''))
+        assert label.text == '[0, 0]|[100, 100]'
+        label.pos = 150, 200
+        assert label.text == '[150, 200]|[100, 100]'
+
+    def test_bind_fstring_reference(self):
+        from kivy.lang import Builder
+        root = Builder.load_string(dedent('''
+        FloatLayout:
+            Label:
+                id: original
+                text: 'perfect'
+            Label:
+                id: duplicate
+                text: f'{original.text}'
+        '''))
+        assert root.ids.duplicate.text == 'perfect'
+        root.ids.original.text = 'new text'
+        assert root.ids.duplicate.text == 'new text'
+
+    def test_bind_fstring_expressions(self):
+        from kivy.lang import Builder
+        root = Builder.load_string(dedent('''
+        FloatLayout:
+            Label:
+                id: original
+                text: 'perfect'
+            Label:
+                id: target1
+                text: f"{' '.join(p.upper() for p in original.text)}"
+            Label:
+                id: target2
+                text: f"{''.join(sorted({p.upper() for p in original.text}))}"
+            Label:
+                id: target3
+                text: f"{'odd' if len(original.text) % 2 else 'even'}"
+            Label:
+                id: target4
+                text: f"{original.text[len(original.text) // 2:]}"
+            Label:
+                id: target5
+                text: f"{not len(original.text) % 2}"
+            Label:
+                id: target6
+                text: f"{original.text}" + " some text"
+        '''))
+        assert root.ids.target1.text == 'P E R F E C T'
+        assert root.ids.target2.text == 'CEFPRT'
+        assert root.ids.target3.text == 'odd'
+        assert root.ids.target4.text == 'fect'
+        assert root.ids.target5.text == 'False'
+        assert root.ids.target6.text == 'perfect some text'
+        root.ids.original.text = 'new text'
+        assert root.ids.target1.text == 'N E W   T E X T'
+        assert root.ids.target2.text == ' ENTWX'
+        assert root.ids.target3.text == 'even'
+        assert root.ids.target4.text == 'text'
+        assert root.ids.target5.text == 'True'
+        assert root.ids.target6.text == 'new text some text'
+
+    def test_bind_fstring_expressions_should_not_bind(self):
+        from kivy.lang import Builder
+        root = Builder.load_string(dedent('''
+        FloatLayout:
+            Label:
+                id: original
+                text: 'perfect'
+            Label:
+                id: target1
+                text: f"{' '.join([original.text for _ in range(2)])}"
+            Label:
+                id: target2
+                text: f"{original.text.upper()}"
+            Label:
+                id: target3
+                text: f"{sum(obj.width for obj in root.children)}"
+        '''))
+        assert root.ids.target1.text == ' '
+        assert root.ids.target2.text == ''
+        assert root.ids.target3.text == '400'
+        root.ids.original.text = 'new text'
+        root.ids.original.width = 0
+        assert root.ids.target1.text == ' '
+        assert root.ids.target2.text == ''
+        assert root.ids.target3.text == '400'
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/kivy/tests/test_lang_complex.py b/kivy/tests/test_lang_complex.py
new file mode 100644
index 0000000..ef0e0fc
--- /dev/null
+++ b/kivy/tests/test_lang_complex.py
@@ -0,0 +1,87 @@
+import unittest
+
+rules = '''
+<CustomLabel>:
+    title: 'invalid'
+<TestWidget>:
+    source: 'invalid.png'
+
+<TestWidget2>:
+    source: 'invalid.png'
+    source3: 'valid.png'
+
+[MItem@TestWidget2]:
+    source: ctx.get('anotherctxvalue')
+
+<MainWidget>:
+    refwid: myref
+    refwid2: myref2
+    MItem:
+        id: myref2
+        anotherctxvalue: 'valid.png'
+    TestWidget:
+        canvas:
+            Color:
+                rgba: 1, 1, 1, 1
+        id: myref
+        source: 'valid.png'
+        source2: 'valid.png'
+        source3: self.source + 'from source3' if self.can_edit else 'valid.png'
+        on_release: root.edit()
+        CustomLabel:
+            title: 'valid'
+'''
+
+
+class LangComplexTestCase(unittest.TestCase):
+
+    def test_complex_rewrite(self):
+        # this test cover a large part of the lang
+        # and was used for testing the validity of the new rewrite lang
+        # however, it's not self explained enough :/
+
+        from kivy.lang import Builder
+        from kivy.uix.widget import Widget
+        from kivy.uix.label import Label
+        from kivy.factory import Factory
+        from kivy.properties import StringProperty, ObjectProperty, \
+            BooleanProperty
+
+        Builder.load_string(rules)
+
+        class TestWidget(Widget):
+            source = StringProperty('')
+            source2 = StringProperty('')
+            source3 = StringProperty('')
+            can_edit = BooleanProperty(False)
+
+            def __init__(self, **kwargs):
+                self.register_event_type('on_release')
+                super(TestWidget, self).__init__(**kwargs)
+
+            def on_release(self):
+                pass
+
+        class MainWidget(Widget):
+            refwid = ObjectProperty(None)
+            refwid2 = ObjectProperty(None)
+
+        class TestWidget2(Widget):
+            pass
+
+        class CustomLabel(Label):
+            pass
+
+        Factory.register('CustomLabel', cls=CustomLabel)
+        Factory.register('TestWidget', cls=TestWidget)
+        Factory.register('TestWidget2', cls=TestWidget2)
+
+        a = MainWidget()
+        self.assertTrue(isinstance(a.refwid, TestWidget))
+        self.assertEqual(a.refwid.source, 'valid.png')
+        self.assertEqual(a.refwid.source2, 'valid.png')
+        self.assertEqual(a.refwid.source3, 'valid.png')
+        self.assertTrue(len(a.refwid.children) == 1)
+        self.assertEqual(a.refwid.children[0].title, 'valid')
+        self.assertTrue(isinstance(a.refwid2, TestWidget2))
+        self.assertEqual(a.refwid2.source, 'valid.png')
diff --git a/kivy/tests/test_lang_pre_process_and_post_process.py b/kivy/tests/test_lang_pre_process_and_post_process.py
new file mode 100644
index 0000000..e30cd80
--- /dev/null
+++ b/kivy/tests/test_lang_pre_process_and_post_process.py
@@ -0,0 +1,394 @@
+import unittest
+import textwrap
+from collections import defaultdict
+
+
+class TrackCallbacks(object):
+
+    kv_pre_events = []
+    '''Stores values added during the pre event dispatched callbacks.
+    '''
+
+    kv_applied_events = []
+    '''Stores values added during the applied event dispatched callbacks.
+    '''
+
+    kv_post_events = []
+    '''Stores values added during the post event dispatched callbacks.
+    '''
+
+    events_in_pre = []
+    '''List of expected events that should be in kv_pre_events after all the
+    callbacks has been executed.
+    '''
+
+    events_in_applied = []
+    '''List of expected events that should be in kv_applied_events after all
+    the callbacks has been executed.
+    '''
+
+    events_in_post = []
+    '''List of expected events that should be in kv_post_events after all the
+    callbacks has been executed.
+    '''
+
+    instantiated_widgets = []
+    '''Whenever a widget of this class is instantiated, it is added to this
+    list, which is class specific.
+
+    It lets us iterate through all the instance of this class and assert for
+    all of them as needed.
+    '''
+
+    root_widget = None
+    '''The expected root widget in the kv rule as dispatched in on_kv_applied.
+    '''
+
+    base_widget = None
+    '''The expected base widget as dispatched in on_kv_post.
+    '''
+
+    actual_root_widget = None
+    '''The actual root widget in the kv rule as dispatched in on_kv_applied.
+    '''
+
+    actual_base_widget = None
+    '''The actual base widget as dispatched in on_kv_post.
+    '''
+
+    name = 'none'
+    '''Optional name given to the widget to help it identify during a test
+    failure.
+    '''
+
+    my_roots_expected_ids = {}
+    '''Dictionary containing the expected ids as stored in the root
+    widget's `ids`. The root being this widget's root widget from kv.
+    '''
+
+    actual_ids = {}
+    '''Dictionary containing the actual ids as stored in the root
+    widget's `ids`. The root being this widget's root widget from kv.
+
+    The ids is saved here during the `on_kv_post` callback.
+    '''
+
+    expected_prop_values = {}
+    '''A dict of property names and the values they are expected to have
+    during the on_kv_post dispatch.
+    '''
+
+    actual_prop_values = {}
+    '''A dict of property names and the values they actually had
+    during the on_kv_post dispatch.
+    '''
+
+    def __init__(self, name='none', **kwargs):
+        self.kv_pre_events = self.kv_pre_events[:]
+        self.kv_applied_events = self.kv_applied_events[:]
+        self.kv_post_events = self.kv_post_events[:]
+        self.events_in_pre = self.events_in_pre[:]
+        self.events_in_applied = self.events_in_applied[:]
+        self.events_in_post = self.events_in_post[:]
+
+        self.name = name
+
+        super(TrackCallbacks, self).__init__(**kwargs)
+        self.instantiated_widgets.append(self)
+
+    def add(self, name, event):
+        '''Add name to the list of the names added in the callbacks for this
+        event.
+        '''
+        events = getattr(self, 'kv_{}_events'.format(event))
+        events.append(name)
+
+    @classmethod
+    def check(cls, testcase):
+        '''Checks that all the widgets of this class pass all the assertions.
+        '''
+        for widget in cls.instantiated_widgets:
+            # check that all the events match
+            for event in ('pre', 'applied', 'post'):
+                cls.check_event(widget, event, testcase)
+
+            # check that the ids are properly saved during on_kv_post dispatch
+            expected = {
+                k: v.__self__ for k, v in widget.my_roots_expected_ids.items()}
+            actual = {k: v.__self__ for k, v in widget.actual_ids.items()}
+            testcase.assertEqual(expected, actual)
+
+            # check that the root widget is as expected
+            testcase.assertIs(
+                widget.root_widget and widget.root_widget.__self__,
+                widget.actual_root_widget and
+                widget.actual_root_widget.__self__,
+                'expected "{}", got "{}" instead for root_widget'.format(
+                    widget.root_widget and widget.root_widget.name,
+                    widget.actual_root_widget and
+                    widget.actual_root_widget.name))
+
+            # check that the base widget is as expected
+            testcase.assertIs(
+                widget.base_widget and widget.base_widget.__self__,
+                widget.actual_base_widget and
+                widget.actual_base_widget.__self__,
+                'expected "{}", got "{}" instead for base_widget'.format(
+                    widget.base_widget and widget.base_widget.name,
+                    widget.actual_base_widget and
+                    widget.actual_base_widget.name))
+
+            # check that the properties have expected values
+            testcase.assertEqual(
+                widget.expected_prop_values, widget.actual_prop_values)
+
+    @staticmethod
+    def check_event(widget, event_name, testcase):
+        '''Check that the names are added as expected for this event.
+        '''
+        events = getattr(widget, 'kv_{}_events'.format(event_name))
+        should_be_in = getattr(widget, 'events_in_{}'.format(event_name))
+
+        counter = defaultdict(int)
+        for name in events:
+            counter[name] += 1
+
+        for name, value in counter.items():
+            testcase.assertEqual(
+                value, 1,
+                '"{}" was present "{}" times for event "{}" for widget "{} '
+                '({})"'.format(name, value, event_name, widget.name, widget))
+
+        testcase.assertEqual(
+            set(should_be_in), set(events),
+            'Expected and actual event callbacks do not match for event "{}" '
+            'for widget "{} ({})"'.format(
+                event_name, widget.name, widget))
+
+    @staticmethod
+    def get_base_class():
+        '''The base class to use for widgets during testing so we can use
+        this class variables to ease testing.
+        '''
+        from kivy.uix.widget import Widget
+
+        class TestEventsBase(TrackCallbacks, Widget):
+
+            __events__ = ('on_kv_pre', 'on_kv_applied')
+
+            instantiated_widgets = []
+
+            events_in_pre = [1, ]
+            events_in_applied = [1, ]
+            events_in_post = [1, ]
+
+            def on_kv_pre(self):
+                self.add(1, 'pre')
+
+            def on_kv_applied(self, root_widget):
+                self.add(1, 'applied')
+                self.actual_root_widget = root_widget
+
+            def on_kv_post(self, base_widget):
+                self.add(1, 'post')
+                self.actual_base_widget = base_widget
+                self.actual_prop_values = {
+                    k: getattr(self, k) for k in self.expected_prop_values}
+
+                if self.actual_root_widget is not None:
+                    # make a copy of the ids at the current moment
+                    self.actual_ids = dict(self.actual_root_widget.ids)
+
+            def apply_class_lang_rules(self, root=None, **kwargs):
+                self.dispatch('on_kv_pre')
+                super(TestEventsBase, self).apply_class_lang_rules(
+                    root=root, **kwargs)
+                self.dispatch('on_kv_applied', root)
+
+        return TestEventsBase
+
+    def __repr__(self):
+        module = type(self).__module__
+        try:
+            qualname = type(self).__qualname__
+        except AttributeError:  # python 2
+            qualname = ''
+        return '<Name: "{}" {}.{} object at {}>'.format(
+            self.name, module, qualname, hex(id(self)))
+
+
+class TestKvEvents(unittest.TestCase):
+
+    def test_pure_python_auto_binding(self):
+        class TestEventsPureAuto(TrackCallbacks.get_base_class()):
+            instantiated_widgets = []
+
+        widget = TestEventsPureAuto()
+        widget.root_widget = None
+        widget.base_widget = widget
+        TestEventsPureAuto.check(self)
+
+    def test_pure_python_callbacks(self):
+        class TestEventsPure(TrackCallbacks.get_base_class()):
+            instantiated_widgets = []
+
+            events_in_pre = [1, 2]
+            events_in_applied = [1, 2]
+            events_in_post = [1, 2]
+
+            def __init__(self, **kwargs):
+                self.fbind('on_kv_pre', lambda _: self.add(2, 'pre'))
+                self.fbind(
+                    'on_kv_applied', lambda _, x: self.add(2, 'applied'))
+                self.fbind('on_kv_post', lambda _, x: self.add(2, 'post'))
+
+                super(TestEventsPure, self).__init__(**kwargs)
+
+        widget = TestEventsPure()
+        widget.root_widget = None
+        widget.base_widget = widget
+
+        widget.fbind('on_kv_pre', lambda _: widget.add(3, 'pre'))
+        widget.fbind('on_kv_applied', lambda _, x: widget.add(3, 'applied'))
+        widget.fbind('on_kv_post', lambda _, x: widget.add(3, 'post'))
+
+        TestEventsPure.check(self)
+
+    def test_instantiate_from_kv(self):
+        from kivy.lang import Builder
+
+        class TestEventsFromKV(TrackCallbacks.get_base_class()):
+            instantiated_widgets = []
+
+        widget = Builder.load_string('TestEventsFromKV')
+        self.assertIsInstance(widget, TestEventsFromKV)
+        widget.root_widget = widget
+        widget.base_widget = widget
+
+        widget.check(self)
+
+    def test_instantiate_from_kv_with_event(self):
+        from kivy.lang import Builder
+
+        class TestEventsFromKVEvent(TrackCallbacks.get_base_class()):
+            instantiated_widgets = []
+
+        widget = Builder.load_string(textwrap.dedent("""
+        TestEventsFromKVEvent:
+            events_in_post: [1, 2]
+            on_kv_pre: self.add(2, 'pre')
+            on_kv_applied: self.add(2, 'applied')
+            on_kv_post: self.add(2, 'post')
+            root_widget: self
+            base_widget: self
+        """))
+
+        self.assertIsInstance(widget, TestEventsFromKVEvent)
+        widget.check(self)
+
+    def test_instantiate_from_kv_with_child(self):
+        from kivy.lang import Builder
+
+        class TestEventsFromKVChild(TrackCallbacks.get_base_class()):
+            instantiated_widgets = []
+
+        widget = Builder.load_string(textwrap.dedent("""
+        TestEventsFromKVChild:
+            events_in_post: [1, 2]
+            on_kv_pre: self.add(2, 'pre')
+            on_kv_applied: self.add(2, 'applied')
+            on_kv_post: self.add(2, 'post')
+            root_widget: self
+            base_widget: self
+            name: 'root'
+            my_roots_expected_ids: {'child_widget': child_widget}
+            TestEventsFromKVChild:
+                events_in_post: [1, 2]
+                on_kv_pre: self.add(2, 'pre')
+                on_kv_applied: self.add(2, 'applied')
+                on_kv_post: self.add(2, 'post')
+                root_widget: root
+                base_widget: root
+                name: 'child'
+                id: child_widget
+                my_roots_expected_ids: {'child_widget': self}
+        """))
+
+        self.assertIsInstance(widget, TestEventsFromKVChild)
+        widget.check(self)
+
+    def test_instantiate_from_kv_with_child_inherit(self):
+        from kivy.lang import Builder
+
+        class TestEventsFromKVChildInherit(TrackCallbacks.get_base_class()):
+            instantiated_widgets = []
+
+        widget = Builder.load_string(textwrap.dedent("""
+        <TestEventsFromKVChildInherit2@TestEventsFromKVChildInherit>:
+            on_kv_pre: self.add(3, 'pre')
+            on_kv_applied: self.add(3, 'applied')
+            on_kv_post: self.add(3, 'post')
+
+        <TestEventsFromKVChildInherit3@TestEventsFromKVChildInherit2>:
+            on_kv_pre: self.add(4, 'pre')
+            on_kv_applied: self.add(4, 'applied')
+            on_kv_post: self.add(4, 'post')
+            some_value: 'fruit'
+            TestEventsFromKVChildInherit2:
+                events_in_applied: [1, 2, 3]
+                events_in_post: [1, 2, 3, 4]
+                on_kv_pre: self.add(4, 'pre')
+                on_kv_applied: self.add(4, 'applied')
+                on_kv_post: self.add(4, 'post')
+                root_widget: root
+                base_widget: self.parent.parent
+                name: 'third child'
+                id: third_child
+                my_roots_expected_ids: {'third_child': self}
+
+        <TestEventsFromKVChildInherit>:
+            on_kv_pre: self.add(2, 'pre')
+            on_kv_applied: self.add(2, 'applied')
+            on_kv_post: self.add(2, 'post')
+            another_value: 'apple'
+
+        TestEventsFromKVChildInherit:
+            events_in_applied: [1, 2]
+            events_in_post: [1, 2, 3]
+            on_kv_pre: self.add(3, 'pre')
+            on_kv_applied: self.add(3, 'applied')
+            on_kv_post: self.add(3, 'post')
+            root_widget: self
+            base_widget: self
+            name: 'root'
+            my_roots_expected_ids: \
+                {'second_child': second_child, 'first_child': first_child}
+            TestEventsFromKVChildInherit:
+                events_in_applied: [1, 2]
+                events_in_post: [1, 2, 3]
+                on_kv_pre: self.add(3, 'pre')
+                on_kv_applied: self.add(3, 'applied')
+                on_kv_post: self.add(3, 'post')
+                root_widget: root
+                base_widget: root
+                name: 'first child'
+                id: first_child
+                my_roots_expected_ids: \
+                    {'second_child': second_child, 'first_child': self}
+            TestEventsFromKVChildInherit3:
+                events_in_applied: [1, 2, 3, 4]
+                events_in_post: [1, 2, 3, 4, 5]
+                on_kv_pre: self.add(5, 'pre')
+                on_kv_applied: self.add(5, 'applied')
+                on_kv_post: self.add(5, 'post')
+                root_widget: root
+                base_widget: root
+                name: 'second child'
+                some_value: first_child.another_value
+                expected_prop_values: {'some_value': 'apple'}
+                id: second_child
+                my_roots_expected_ids: \
+                    {'second_child': self, 'first_child': first_child}
+        """))
+
+        widget.check(self)
diff --git a/kivy/tests/test_logger.py b/kivy/tests/test_logger.py
new file mode 100644
index 0000000..90269b1
--- /dev/null
+++ b/kivy/tests/test_logger.py
@@ -0,0 +1,60 @@
+"""
+Logger tests
+============
+"""
+
+import pytest
+import pathlib
+import time
+
+
+@pytest.fixture
+def file_handler():
+    # restores handler to original state
+    from kivy.config import Config
+
+    log_dir = Config.get("kivy", "log_dir")
+    log_maxfiles = Config.get("kivy", "log_maxfiles")
+
+    try:
+        yield None
+    finally:
+        Config.set("kivy", "log_dir", log_dir)
+        Config.set("kivy", "log_maxfiles", log_maxfiles)
+
+
+@pytest.mark.parametrize('n', [0, 1, 5])
+def test_purge_logs(tmp_path, file_handler, n):
+    from kivy.config import Config
+    from kivy.logger import FileHandler
+
+    Config.set("kivy", "log_dir", str(tmp_path))
+    Config.set("kivy", "log_maxfiles", n)
+
+    # create the default file first so it gets deleted so names match
+    handler = FileHandler()
+    handler._configure()
+    open_file = pathlib.Path(handler.filename).name
+    # wait a little so the timestamps are different for different files
+    time.sleep(.05)
+
+    names = [f'log_{i}.txt' for i in range(n + 2)]
+    for name in names:
+        p = tmp_path / name
+        p.write_text('some data')
+        time.sleep(.05)
+
+    handler.purge_logs()
+
+    # files that should have remained after purge
+    expected_names = list(reversed(names))[:n]
+    files = {f.name for f in tmp_path.iterdir()}
+    if open_file in files:
+        # one of the remaining files is the current open log, remove it
+        files.remove(open_file)
+        if len(expected_names) == len(files) + 1:
+            # the open log may or may not have been counted in the remaining
+            # files, remove one from expected to match removed open file
+            expected_names = expected_names[:-1]
+
+    assert set(expected_names) == files
diff --git a/kivy/tests/test_metrics.py b/kivy/tests/test_metrics.py
new file mode 100644
index 0000000..0643d90
--- /dev/null
+++ b/kivy/tests/test_metrics.py
@@ -0,0 +1,30 @@
+import pytest
+
+
+@pytest.mark.parametrize('unit', ['inch', 'dp', 'sp', 'pt', 'cm', 'mm'])
+def test_metrics_scale_factors(kivy_metrics, unit):
+    from kivy.metrics import dpi2px
+    import kivy.metrics as m
+    kivy_metrics.density = 2
+    kivy_metrics.dpi = 101
+    kivy_metrics.fontscale = 3
+
+    factor = getattr(kivy_metrics, unit)
+    print(kivy_metrics.fontscale)
+    assert pytest.approx(7 * factor) == dpi2px(7, unit[:2])  # inch -> in
+    assert pytest.approx(7 * factor) == getattr(m, unit)(7)
+
+    kivy_metrics.density = 5
+    kivy_metrics.dpi = 103
+    kivy_metrics.fontscale = 11
+
+    new_factor = getattr(kivy_metrics, unit)
+    assert new_factor != pytest.approx(factor)
+    assert pytest.approx(7 * new_factor) == dpi2px(7, unit[:2])
+    assert pytest.approx(7 * new_factor) == getattr(m, unit)(7)
+    assert pytest.approx(7 * factor) != dpi2px(7, unit[:2])
+    assert pytest.approx(7 * factor) != getattr(m, unit)(7)
+
+    # assert pytest.approx(10 * new_factor) == dpi2px(10, unit)
+    assert pytest.approx(100 * new_factor) == dpi2px(100, unit[:2])
+    assert pytest.approx(1000 * new_factor) == dpi2px(1000, unit[:2])
diff --git a/kivy/tests/test_module_inspector.py b/kivy/tests/test_module_inspector.py
new file mode 100644
index 0000000..a1d8ac5
--- /dev/null
+++ b/kivy/tests/test_module_inspector.py
@@ -0,0 +1,382 @@
+import unittest
+from kivy.tests.common import GraphicUnitTest, UnitTestTouch
+from kivy.base import EventLoop
+from kivy.modules import inspector
+from kivy.factory import Factory
+
+
+KV = '''
+#:import Factory kivy.factory.Factory
+
+<InspectorTestModal@ModalView>:
+    size_hint: 0.5, 0.5
+
+<FirstModal@InspectorTestModal>:
+    Button:
+        id: firstmodal
+        text: 'first modal'
+        on_release: Factory.SecondModal().open()
+
+<SecondModal@InspectorTestModal>:
+    Button:
+        id: secondmodal
+        text: 'second modal'
+        on_release: Factory.ThirdModal().open()
+
+<ThirdModal@InspectorTestModal>:
+    Button:
+        id: thirdmodal
+        text: 'third modal'
+
+BoxLayout:
+    Button:
+        id: highlight
+        text: 'highlight'
+    Button:
+        id: popup
+        text: 'popup'
+        on_release: Factory.FirstModal().open()
+    Button:
+        id: tri_popup
+        text: '3 popups'
+        on_release: Factory.FirstModal().open()
+    Button:
+        id: dummy
+        text: 'dummy'
+'''
+
+
+class InspectorTestCase(GraphicUnitTest):
+    framecount = 0
+
+    def setUp(self):
+        # kill KV lang logging (too long test)
+        import kivy.lang.builder as builder
+
+        if not hasattr(self, '_trace'):
+            self._trace = builder.trace
+
+        self.builder = builder
+        builder.trace = lambda *_, **__: None
+        super(InspectorTestCase, self).setUp()
+
+    def tearDown(self, *args, **kwargs):
+        # add the logging back
+        import kivy.lang.builder as builder
+        builder.Builder.unload_file("InspectorTestCase.KV")
+        builder.trace = self._trace
+        super(InspectorTestCase, self).tearDown(*args, **kwargs)
+
+    def clean_garbage(self, *args):
+        for child in self._win.children[:]:
+            self._win.remove_widget(child)
+        self.advance_frames(5)
+
+    def test_activate_deactivate_bottom(self, *args):
+        EventLoop.ensure_window()
+        self._win = EventLoop.window
+
+        self.clean_garbage()
+
+        # build the widget tree & add Window as the main EL
+        self.root = self.builder.Builder.load_string(
+            KV, filename="InspectorTestCase.KV")
+        self.render(self.root)
+        self.assertLess(len(self._win.children), 2)
+
+        # activate inspector with root as ctx
+        inspector.start(self._win, self.root)
+        self.advance_frames(2)
+
+        # pull the Inspector drawer from bottom
+        ins = self.root.inspector
+        ins.activated = True
+        ins.inspect_enabled = True
+        self.assertTrue(ins.at_bottom)
+
+        # by default is Inspector appended as the first child
+        # to the window and positioned at the bottom
+        self.assertEqual(self._win.children[0], ins)
+        self.advance_frames(1)
+        self.assertLess(ins.layout.pos[1], self._win.height / 2.0)
+
+        # close Inspector
+        ins.inspect_enabled = False
+        ins.activated = False
+        self.render(self.root)
+        self.advance_frames(1)
+
+        # stop Inspector completely
+        inspector.stop(self._win, self.root)
+        self.assertLess(len(self._win.children), 2)
+        self.render(self.root)
+
+    def test_activate_deactivate_top(self, *args):
+        EventLoop.ensure_window()
+        self._win = EventLoop.window
+
+        self.clean_garbage()
+
+        # build the widget tree & add Window as the main EL
+        self.root = self.builder.Builder.load_string(
+            KV, filename="InspectorTestCase.KV")
+        self.render(self.root)
+        self.assertLess(len(self._win.children), 2)
+
+        # activate inspector with root as ctx
+        inspector.start(self._win, self.root)
+        self.advance_frames(2)
+
+        # pull the Inspector drawer from top
+        ins = self.root.inspector
+        ins.at_bottom = False
+        ins.activated = True
+        ins.inspect_enabled = True
+        self.assertFalse(ins.at_bottom)
+
+        # by default is Inspector appended as the first child
+        # to the window & we move it to the top
+        self.assertEqual(self._win.children[0], ins)
+        ins.toggle_position(self.root.ids.dummy)
+        self.advance_frames(20)  # drawer is moving, like with activate
+        self.assertGreater(ins.layout.pos[1], self._win.height / 2.0)
+
+        # close Inspector
+        ins.inspect_enabled = False
+        ins.activated = False
+        self.render(self.root)
+        self.advance_frames(1)
+
+        # stop Inspector completely
+        inspector.stop(self._win, self.root)
+        self.assertLess(len(self._win.children), 2)
+        self.render(self.root)
+
+    def test_widget_button(self, *args):
+        EventLoop.ensure_window()
+        self._win = EventLoop.window
+
+        self.clean_garbage()
+
+        # build the widget tree & add Window as the main EL
+        self.root = self.builder.Builder.load_string(
+            KV, filename="InspectorTestCase.KV")
+        self.render(self.root)
+        self.assertLess(len(self._win.children), 2)
+
+        # checked widget
+        highlight = self.root.ids.highlight
+        highlight_exp = self.root.ids.highlight.text
+
+        # activate inspector with root as ctx
+        inspector.start(self._win, self.root)
+        self.advance_frames(2)
+
+        # pull the Inspector drawer from bottom
+        ins = self.root.inspector
+        ins.activated = True
+        ins.inspect_enabled = True
+        self.assertTrue(ins.at_bottom)
+
+        # touch button center
+        touch = UnitTestTouch(*highlight.center)
+        touch.touch_down()
+        touch.touch_up()
+
+        # open Inspector properties
+        ins.show_widget_info()
+        self.advance_frames(2)
+
+        # check if the button is selected
+        # stored instance
+        self.assertEqual(ins.widget.text, highlight_exp)
+        # data in properties
+        for node in ins.treeview.iterate_all_nodes():
+            lkey = getattr(node.ids, 'lkey', None)
+            if not lkey:
+                continue
+            if lkey.text == 'text':
+                ltext = node.ids.ltext
+                # slice because the string is displayed with quotes
+                self.assertEqual(ltext.text[1:-1], highlight_exp)
+                break
+
+        # close Inspector
+        ins.inspect_enabled = False
+        ins.activated = False
+        self.render(self.root)
+        self.advance_frames(1)
+
+        # stop Inspector completely
+        inspector.stop(self._win, self.root)
+        self.assertLess(len(self._win.children), 2)
+        self.render(self.root)
+
+    def test_widget_popup(self, *args):
+        EventLoop.ensure_window()
+        self._win = EventLoop.window
+
+        self.clean_garbage()
+
+        # build the widget tree & add Window as the main EL
+        self.root = self.builder.Builder.load_string(
+            KV, filename="InspectorTestCase.KV")
+        self.render(self.root)
+        self.assertLess(len(self._win.children), 2)
+
+        # checked widget
+        popup = self.root.ids.popup
+
+        # activate inspector with root as ctx
+        inspector.start(self._win, self.root)
+        self.advance_frames(1)
+
+        # pull the Inspector drawer from bottom,
+        # but don't inspect yet!
+        ins = self.root.inspector
+        ins.inspect_enabled = False
+        ins.activated = True
+        self.assertTrue(ins.at_bottom)
+
+        # touch button center to open the popup
+        touch = UnitTestTouch(*popup.center)
+        touch.touch_down()
+        touch.touch_up()
+        self.advance_frames(1)
+
+        # start inspecting
+        ins.inspect_enabled = True
+        self.advance_frames(1)
+
+        # inspect FirstModal's button
+        touch.touch_down()
+        touch.touch_up()
+        self.advance_frames(1)
+
+        # open Inspector properties
+        ins.show_widget_info()
+        self.advance_frames(2)
+
+        # check if the popup is selected
+        # stored instance
+        self.assertIsInstance(ins.widget, Factory.Button)
+        self.assertIsInstance(ins.widget.parent, Factory.FirstModal)
+        # check with new Popup instance if the properties match
+        temp_popup = Factory.FirstModal()
+        temp_popup_exp = temp_popup.ids.firstmodal.text
+        self.assertEqual(ins.widget.text, temp_popup_exp)
+        # data in properties
+        for node in ins.treeview.iterate_all_nodes():
+            lkey = getattr(node.ids, 'lkey', None)
+            if not lkey:
+                continue
+            if lkey.text == 'text':
+                ltext = node.ids.ltext
+                # slice because the string is displayed with quotes
+                self.assertEqual(ltext.text[1:-1], temp_popup_exp)
+                break
+        del temp_popup
+
+        # close popup
+        ins.inspect_enabled = False
+        touch = UnitTestTouch(0, 0)
+        touch.touch_down()
+        touch.touch_up()
+        self.advance_frames(10)
+
+        # close Inspector
+        ins.activated = False
+        self.render(self.root)
+        self.advance_frames(5)
+
+        # stop Inspector completely
+        inspector.stop(self._win, self.root)
+        self.assertLess(len(self._win.children), 2)
+        self.render(self.root)
+
+    @unittest.skip("doesn't work on CI with Python 3.5 but works locally")
+    def test_widget_multipopup(self, *args):
+        EventLoop.ensure_window()
+        self._win = EventLoop.window
+
+        self.clean_garbage()
+
+        # build the widget tree & add Window as the main EL
+        self.root = self.builder.Builder.load_string(
+            KV, filename="InspectorTestCase.KV")
+        self.render(self.root)
+        self.assertLess(len(self._win.children), 2)
+
+        # checked widget
+        popup = self.root.ids.popup
+
+        # activate inspector with root as ctx
+        inspector.start(self._win, self.root)
+        self.advance_frames(1)
+
+        # pull the Inspector drawer from bottom,
+        # but don't inspect yet!
+        ins = self.root.inspector
+        ins.inspect_enabled = False
+        ins.activated = True
+        self.assertTrue(ins.at_bottom)
+
+        # touch button center to open the popup
+        touch = UnitTestTouch(*popup.center)
+        touch.touch_down()
+        touch.touch_up()
+        self.advance_frames(1)
+
+        # touch Window center to open
+        # the second and the third popup
+        touch = UnitTestTouch(
+            self._win.width / 2.0,
+            self._win.height / 2.0
+        )
+        for i in range(2):
+            touch.touch_down()
+            touch.touch_up()
+            self.advance_frames(1)
+
+        # fixed order, first opened - last closed
+        modals = [
+            Factory.ThirdModal,
+            Factory.SecondModal,
+            Factory.FirstModal
+        ]
+        for mod in modals:
+            # start inspecting
+            ins.inspect_enabled = True
+            self.advance_frames(1)
+
+            # inspect button
+            touch.touch_down()
+            touch.touch_up()
+            self.advance_frames(1)
+
+            # check if the popup is selected
+            # stored instance
+            self.assertIsInstance(ins.widget, Factory.Button)
+            self.assertIsInstance(ins.widget.parent, mod)
+
+            # close popup
+            ins.inspect_enabled = False
+            orig = UnitTestTouch(0, 0)
+            orig.touch_down()
+            orig.touch_up()
+            self.advance_frames(10)
+
+        # close Inspector
+        ins.activated = False
+        self.render(self.root)
+        self.advance_frames(5)
+
+        # stop Inspector completely
+        inspector.stop(self._win, self.root)
+        self.assertLess(len(self._win.children), 2)
+        self.render(self.root)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_motion_event.py b/kivy/tests/test_motion_event.py
new file mode 100644
index 0000000..074abf7
--- /dev/null
+++ b/kivy/tests/test_motion_event.py
@@ -0,0 +1,44 @@
+import pytest
+
+from kivy.compat import isclose
+from kivy.input import MotionEvent
+
+
+class DummyMotionEvent(MotionEvent):
+    pass
+
+
+class TestMotionEvent:
+
+    def create_dummy_motion_event(self):
+        return DummyMotionEvent('dummy', 'dummy1', (0, 0))
+
+    def build_to_absolute_pos_data(self, x_max, y_max, x_step, y_step):
+        for x, y in zip(range(0, x_max, x_step), range(0, y_max, y_step)):
+            result = (x, y)
+            yield x / x_max, y / y_max, x_max, y_max, 0, result
+        for x, y, in zip(range(0, x_max, x_step), range(0, y_max, y_step)):
+            result = (y, x_max - x)
+            yield x / x_max, y / y_max, x_max, y_max, 90, result
+        for x, y, in zip(range(0, x_max, x_step), range(0, y_max, y_step)):
+            result = (x_max - x, y_max - y)
+            yield x / x_max, y / y_max, x_max, y_max, 180, result
+        for x, y, in zip(range(0, x_max, x_step), range(0, y_max, y_step)):
+            result = (y_max - y, x)
+            yield x / x_max, y / y_max, x_max, y_max, 270, result
+
+    def test_to_absolute_pos(self):
+        event = self.create_dummy_motion_event()
+        for item in self.build_to_absolute_pos_data(320, 240, 20, 21):
+            args = item[:-1]
+            expected_x, expected_y = item[-1]
+            x, y = event.to_absolute_pos(*args)
+            message = ('For args {} expected ({}, {}), got ({}, {})'
+                       .format(args, expected_x, expected_y, x, y))
+            correct = isclose(x, expected_x) and isclose(y, expected_y)
+            assert correct, message
+
+    def test_to_absolute_pos_error(self):
+        event = self.create_dummy_motion_event()
+        with pytest.raises(ValueError):
+            event.to_absolute_pos(0, 0, 100, 100, 10)
diff --git a/kivy/tests/test_mouse_hover_event.py b/kivy/tests/test_mouse_hover_event.py
new file mode 100644
index 0000000..9ed9ced
--- /dev/null
+++ b/kivy/tests/test_mouse_hover_event.py
@@ -0,0 +1,249 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class MouseHoverEventTestCase(GraphicUnitTest):
+    '''Tests hover event from `MouseMotionEventProvider`.
+    '''
+
+    def setUp(self):
+        super().setUp()
+        self.etype = None
+        self.motion_event = None
+        self.touch_event = None
+        self.button_widget = None
+        from kivy.input.providers.mouse import MouseMotionEventProvider
+        self.mouse = mouse = MouseMotionEventProvider('mouse', '')
+        from kivy.base import EventLoop
+        win = EventLoop.window
+        self.old_mouse_pos = win.mouse_pos[:]
+        self.old_rotation = win.rotation
+        self.old_system_size = win.system_size[:]
+        win.mouse_pos = (0.0, 0.0)
+        win.rotation = 0
+        win.system_size = (320, 240)
+        mouse.start()
+        EventLoop.add_input_provider(mouse)
+        win.fbind('on_motion', self.on_motion)
+        # Patch `win.on_close` method to prevent EventLoop from removing
+        # window from event listeners list.
+        self.old_on_close = win.on_close
+        win.on_close = lambda *args: None
+
+    def tearDown(self, *args, **kwargs):
+        self.etype = None
+        self.motion_event = None
+        self.touch_event = None
+        from kivy.base import EventLoop
+        win = EventLoop.window
+        win.mouse_pos = self.old_mouse_pos
+        win.rotation = self.old_rotation
+        win.old_system_size = self.old_system_size
+        self.old_mouse_pos = None
+        self.old_rotation = None
+        self.old_system_size = None
+        if self.button_widget:
+            win.remove_widget(self.button_widget)
+            self.button_widget = None
+        mouse = self.mouse
+        mouse.stop()
+        EventLoop.remove_input_provider(mouse)
+        self.mouse = None
+        win.funbind('on_motion', self.on_motion)
+        # Restore method `on_close` to window
+        win.on_close = self.old_on_close
+        self.old_on_close = None
+        super().tearDown(*args, **kwargs)
+
+    def on_window_flip(self, window):
+        # Not rendering widgets in tests so don't do screenshots
+        pass
+
+    def on_motion(self, _, etype, event):
+        self.etype = etype
+        self.motion_event = event
+
+    def on_any_touch_event(self, _, touch):
+        self.touch_event = touch
+
+    def assert_event(self, etype, spos):
+        assert self.etype == etype
+        assert 'pos' in self.motion_event.profile
+        assert self.motion_event.is_touch is False
+        assert self.motion_event.spos == spos
+
+    def assert_no_event(self):
+        assert self.etype is None
+        assert self.motion_event is None
+
+    def get_providers(self, with_window_children=False):
+        from kivy.base import EventLoop
+        win = EventLoop.window
+        if with_window_children:
+            from kivy.uix.button import Button
+            button = Button(on_touch_down=self.on_any_touch_event,
+                            on_touch_move=self.on_any_touch_event,
+                            on_touch_up=self.on_any_touch_event)
+            self.button_widget = button
+            win.add_widget(button)
+        return win, self.mouse
+
+    def test_no_event_on_cursor_leave(self):
+        win, mouse = self.get_providers()
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+        self.assert_no_event()
+
+    def test_no_event_on_system_size(self):
+        win, mouse = self.get_providers()
+        w, h = win.system_size
+        win.system_size = (w + 10, h + 10)
+        self.advance_frames(1)
+        self.assert_no_event()
+
+    def test_no_event_on_rotate(self):
+        win, mouse = self.get_providers()
+        win.rotation = 90
+        self.advance_frames(1)
+        self.assert_no_event()
+
+    def test_no_event_on_close(self):
+        win, mouse = self.get_providers()
+        win.dispatch('on_close')
+        self.advance_frames(1)
+        self.assert_no_event()
+
+    def test_begin_event_on_cursor_enter(self):
+        win, mouse = self.get_providers()
+        x, y = win.mouse_pos
+        win.dispatch('on_cursor_enter')
+        self.advance_frames(1)
+        self.assert_event('begin', win.to_normalized_pos(x, y))
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_begin_event_on_mouse_pos(self):
+        win, mouse = self.get_providers()
+        x, y = win.mouse_pos = (10.0, 10.0)
+        self.advance_frames(1)
+        self.assert_event('begin', win.to_normalized_pos(x, y))
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_update_event_with_enter_and_mouse_pos(self):
+        win, mouse = self.get_providers()
+        win.dispatch('on_cursor_enter')
+        x, y = win.mouse_pos = (50.0, 50.0)
+        self.advance_frames(1)
+        self.assert_event('update', win.to_normalized_pos(x, y))
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_update_event_with_mouse_pos(self):
+        win, mouse = self.get_providers()
+        win.mouse_pos = (10.0, 10.0)
+        x, y = win.mouse_pos = (50.0, 50.0)
+        self.advance_frames(1)
+        self.assert_event('update', win.to_normalized_pos(x, y))
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_update_event_on_rotate(self):
+        win, mouse = self.get_providers()
+        x, y = win.mouse_pos = (10.0, 10.0)
+        win.rotation = 90
+        self.advance_frames(1)
+        self.assert_event('update', win.to_normalized_pos(x, y))
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_update_event_on_system_size(self):
+        win, mouse = self.get_providers()
+        x, y = win.mouse_pos = (10.0, 10.0)
+        w, h = win.system_size
+        win.system_size = (w + 10, h + 10)
+        self.advance_frames(1)
+        self.assert_event('update', win.to_normalized_pos(x, y))
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_end_event_on_cursor_leave(self):
+        win, mouse = self.get_providers()
+        x, y = win.mouse_pos = (10.0, 10.0)
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+        self.assert_event('end', win.to_normalized_pos(x, y))
+
+    def test_end_event_on_window_close(self):
+        win, mouse = self.get_providers()
+        x, y = win.mouse_pos = (10.0, 10.0)
+        win.dispatch('on_close')
+        self.advance_frames(1)
+        self.assert_event('end', win.to_normalized_pos(x, y))
+
+    def test_with_full_cycle_with_cursor_events(self):
+        win, mouse = self.get_providers()
+        # Test begin event
+        win.dispatch('on_cursor_enter')
+        x, y = win.mouse_pos
+        self.advance_frames(1)
+        self.assert_event('begin', win.to_normalized_pos(x, y))
+        # Test update event
+        x, y = win.mouse_pos = (10.0, 10.0)
+        self.advance_frames(1)
+        self.assert_event('update', win.to_normalized_pos(x, y))
+        # Test end event
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+        self.assert_event('end', win.to_normalized_pos(x, y))
+
+    def test_with_full_cycle_with_mouse_pos_and_on_close_event(self):
+        win, mouse = self.get_providers()
+        # Test begin event
+        x, y = win.mouse_pos = (5.0, 5.0)
+        self.advance_frames(1)
+        self.assert_event('begin', win.to_normalized_pos(x, y))
+        # Test update event
+        x, y = win.mouse_pos = (10.0, 10.0)
+        self.advance_frames(1)
+        self.assert_event('update', win.to_normalized_pos(x, y))
+        # Test end event
+        win.dispatch('on_close')
+        self.advance_frames(1)
+        self.assert_event('end', win.to_normalized_pos(x, y))
+
+    def test_begin_event_no_dispatch_through_on_touch_events(self):
+        win, mouse = self.get_providers(with_window_children=True)
+        x, y = win.mouse_pos
+        win.dispatch('on_cursor_enter')
+        self.advance_frames(1)
+        self.assert_event('begin', win.to_normalized_pos(x, y))
+        assert self.touch_event is None
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_update_event_no_dispatch_through_on_touch_events(self):
+        win, mouse = self.get_providers(with_window_children=True)
+        win.dispatch('on_cursor_enter')
+        x, y = win.mouse_pos = (10.0, 10.0)
+        self.advance_frames(1)
+        self.assert_event('update', win.to_normalized_pos(x, y))
+        assert self.touch_event is None
+        # Cleanup
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+
+    def test_end_event_no_dispatch_through_on_touch_events(self):
+        win, mouse = self.get_providers(with_window_children=True)
+        win.dispatch('on_cursor_enter')
+        x, y = win.mouse_pos = (10.0, 10.0)
+        win.dispatch('on_cursor_leave')
+        self.advance_frames(1)
+        self.assert_event('end', win.to_normalized_pos(x, y))
+        assert self.touch_event is None
diff --git a/kivy/tests/test_mouse_multitouchsim.py b/kivy/tests/test_mouse_multitouchsim.py
new file mode 100644
index 0000000..5912b14
--- /dev/null
+++ b/kivy/tests/test_mouse_multitouchsim.py
@@ -0,0 +1,554 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class MultitouchSimulatorTestCase(GraphicUnitTest):
+
+    framecount = 3
+
+    def render(self, root, framecount=1):
+        pass
+
+    # helper methods
+    def correct_y(self, win, y):
+        # flip, because the mouse provider uses system's
+        # raw one and it's changed to bottom-left origin
+        # with Window's system_size[1] for 'mouse_pos'
+        return win.height - 1.0 - y
+
+    def mouse_init(self, on_demand=False, disabled=False, scatter=False):
+        # prepare MouseMotionEventProvider
+        # and widget it interacts with
+        from kivy.base import EventLoop
+        from kivy.uix.button import Button
+        from kivy.uix.scatter import Scatter
+
+        eventloop = EventLoop
+        win = eventloop.window
+        eventloop.idle()
+        wid = Scatter() if scatter else Button()
+
+        if on_demand:
+            mode = 'multitouch_on_demand'
+        elif disabled:
+            mode = 'disable_multitouch'
+        else:
+            mode = ''
+        from kivy.input.providers.mouse import MouseMotionEventProvider
+        mouse = MouseMotionEventProvider('unittest', mode)
+        mouse.is_touch = True
+
+        # defaults from ME, it's missing because we use
+        # the provider directly instead of ME
+        mouse.scale_for_screen = lambda *_, **__: None
+        mouse.grab_exclusive_class = None
+        mouse.grab_list = []
+
+        if on_demand:
+            self.assertTrue(mouse.multitouch_on_demand)
+        return (eventloop, win, mouse, wid)
+
+    def multitouch_dot_touch(self, button, **kwargs):
+        # touch -> dot appears -> touch again -> dot disappears
+        eventloop, win, mouse, wid = self.mouse_init(**kwargs)
+
+        # register mouse provider
+        mouse.start()
+        eventloop.add_input_provider(mouse)
+
+        # no mouse touch anywhere
+        self.assertEqual(mouse.counter, 0)
+        self.assertEqual(mouse.touches, {})
+
+        # right button down, red dot should appear
+        win.dispatch(
+            'on_mouse_down',
+            10, self.correct_y(win, 10),
+            'right', {}
+        )
+        event_id = next(iter(mouse.touches))
+        self.assertEqual(mouse.counter, 1)
+
+        if 'on_demand' in kwargs and 'scatter' not in kwargs:
+            # doesn't do anything on a pure Button
+            self.render(wid)
+
+            # cleanup!
+            # remove mouse provider
+            mouse.stop()
+            eventloop.remove_input_provider(mouse)
+            return
+
+        elif 'on_demand' in kwargs and 'scatter' in kwargs:
+            self.assertIn(
+                'multitouch_sim',
+                mouse.touches[event_id].profile
+            )
+            self.assertTrue(mouse.multitouch_on_demand)
+
+            # multitouch_sim is changed in on_touch_down
+            # method of the widget that's able to handle
+            # multiple touches, therefore for Scatter we
+            # need to dispatch the method and because we
+            # triggered only on_mouse_down directly i.e.
+            # without ME dispatch, on_touch_down was not
+            # called == multitouch_sim is False
+            self.advance_frames(1)  # initialize stuff
+            wid.on_touch_down(mouse.touches[event_id])
+            wid.on_touch_up(mouse.touches[event_id])
+            self.assertTrue(mouse.touches[event_id].multitouch_sim)
+
+        elif 'disabled' in kwargs:
+            self.assertIsNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot isn't present
+
+        else:
+            self.assertIsNotNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot is present
+
+        # XXX right button up
+        # first release the touch then check, so that we
+        # have the red dot drawn in on_demand and in the
+        # default (multitouch everywhere) because in the
+        # multitouch_on_demand is the circle drawn after
+        # the touch is released (in on_mouse_release)
+        win.dispatch(
+            'on_mouse_up',
+            10, self.correct_y(win, 10),
+            'right', {}
+        )
+
+        self.assertEqual(mouse.counter, 1)
+
+        # because the red dot is removed by the left button
+        if 'disabled' not in kwargs:
+            self.assertIn(event_id, mouse.touches)
+            self.assertIsNotNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot is present
+
+        # button is down on the previous dot's position
+        win.dispatch(
+            'on_mouse_down',
+            10, self.correct_y(win, 10),
+            button, {}
+        )
+        # if the multitouch is disabled, the touch event
+        # increments the counter
+        self.assertEqual(
+            mouse.counter,
+            1 + int('disabled' in kwargs)
+        )
+        if 'disabled' in kwargs:
+            # the right click is ignored, test ends here
+            self.assertNotIn(
+                event_id, mouse.touches
+            )
+            # cleanup!
+            # remove mouse provider
+            mouse.stop()
+            eventloop.remove_input_provider(mouse)
+            return
+        else:
+            self.assertIsNotNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot is present
+
+        # ellipse proxy (<3 #1318 Instruction.proxy_ref)
+        dot_proxy = mouse.touches[
+            event_id
+        ].ud.get('_drawelement')[1].proxy_ref
+
+        # the dot is removed after the touch is released
+        # when right - touch is preserved -> dot remains
+        # when left  - touch is destroyed -> dot removed
+        win.dispatch(
+            'on_mouse_up',
+            10, self.correct_y(win, 10),
+            button, {}
+        )  # no matter where
+
+        # the touch, which holds the only ref to the dot
+        # instance (Ellipse) is collected, therefore the
+        # proxy can confirm the dot is removed
+        # (indirect ref at least + it would be nasty for
+        # checking if the ellipse remained on visible on
+        # the Canvas after being GC-ed if not impossible
+        # without the Instruction object trick ._. )
+        if button == 'left':
+            with self.assertRaises(ReferenceError):
+                print(dot_proxy)
+
+            self.assertEqual(mouse.counter, 1)
+            self.assertNotIn(event_id, mouse.touches)
+            self.assertEqual(mouse.touches, {})
+
+        elif button == 'right':
+            self.assertEqual(mouse.counter, 1)
+            self.assertIn(event_id, mouse.touches)
+            self.assertIsNotNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot is present
+
+        self.render(wid)
+
+        # cleanup!
+        # remove mouse provider
+        mouse.stop()
+        eventloop.remove_input_provider(mouse)
+
+    def multitouch_dot_move(self, button, **kwargs):
+        # touch -> dot appears -> move touch -> dot moves
+        # -> release touch -> touch & dot disappear
+        eventloop, win, mouse, wid = self.mouse_init(**kwargs)
+
+        # register mouse provider
+        mouse.start()
+        eventloop.add_input_provider(mouse)
+
+        # no mouse touch anywhere
+        self.assertEqual(mouse.counter, 0)
+        self.assertEqual(mouse.touches, {})
+
+        # right button down, red dot should appear
+        # if the 'multitouch_on_demand' is disabled
+        win.dispatch(
+            'on_mouse_down',
+            10, self.correct_y(win, 10),
+            'right', {}
+        )
+        event_id = next(iter(mouse.touches))
+        self.assertEqual(mouse.counter, 1)
+
+        if 'on_demand' in kwargs and 'scatter' not in kwargs:
+            # doesn't do anything on a pure Button
+            self.render(wid)
+
+            # cleanup!
+            # remove mouse provider
+            mouse.stop()
+            eventloop.remove_input_provider(mouse)
+            return
+
+        # XXX right button up
+        # first release the touch then check, so that we
+        # have the red dot drawn in on_demand and in the
+        # default (multitouch everywhere) because in the
+        # multitouch_on_demand is the circle drawn after
+        # the touch is released (in on_mouse_release)
+        elif 'on_demand' in kwargs and 'scatter' in kwargs:
+            # on_demand works after the touch is up
+            self.assertIn(
+                'multitouch_sim',
+                mouse.touches[event_id].profile
+            )
+            self.assertTrue(mouse.multitouch_on_demand)
+
+            # multitouch_sim is changed in on_touch_down
+            # method of the widget that's able to handle
+            # multiple touches, therefore for Scatter we
+            # need to dispatch the method and because we
+            # triggered only on_mouse_down directly i.e.
+            # without ME dispatch, on_touch_down was not
+            # called == multitouch_sim is False
+            self.advance_frames(1)  # initialize stuff
+            wid.on_touch_down(mouse.touches[event_id])
+            wid.on_touch_up(mouse.touches[event_id])
+            self.assertTrue(mouse.touches[event_id].multitouch_sim)
+
+            win.dispatch(
+                'on_mouse_up',
+                10, self.correct_y(win, 10),
+                'right', {}
+            )
+            ellipse = mouse.touches[
+                event_id
+            ].ud.get('_drawelement')[1].proxy_ref
+            win.dispatch(
+                'on_mouse_down',
+                10, self.correct_y(win, 10),
+                'right', {}
+            )
+
+        elif 'disabled' in kwargs:
+            self.assertIsNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot isn't present
+
+        else:
+            self.assertIsNotNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot is present
+
+        # do NOT make any hard refs to '_drawelement'
+        if 'disabled' in kwargs:
+            # the right click doesn't draw the red dot
+            # the instructions aren't present, test ends
+            self.assertIsNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot isn't present
+            # cleanup!
+            # remove mouse provider
+            mouse.stop()
+            eventloop.remove_input_provider(mouse)
+            return
+
+        else:
+            ellipse = mouse.touches[
+                event_id
+            ].ud.get('_drawelement')[1].proxy_ref
+
+        # the red dot moves when the touch is moving
+        win.dispatch(
+            'on_mouse_move',
+            11, self.correct_y(win, 11),
+            {}
+        )
+        self.assertEqual(
+            ellipse.pos,
+            (1, 1)
+        )  # bounding box from Rectangle, R=10 -> 20 width
+
+        # right button up
+        win.dispatch(
+            'on_mouse_up',
+            10, self.correct_y(win, 10),
+            'right', {}
+        )
+        self.assertEqual(mouse.counter, 1)
+
+        # because the red dot is removed by the left button
+        self.assertIn(event_id, mouse.touches)
+        self.assertIsNotNone(
+            mouse.touches[event_id].ud.get('_drawelement')
+        )  # the red dot is present
+
+        # the dot is at (11, 11), but the touch is in
+        # its bounding box, therefore it can move it
+        win.dispatch(
+            'on_mouse_down',
+            10, self.correct_y(win, 10),
+            button, {}
+        )
+
+        # manipulating already existing touch,
+        # no new one was created
+        self.assertEqual(mouse.counter, 1)
+        self.assertIsNotNone(
+            mouse.touches[event_id].ud.get('_drawelement')
+        )  # the red dot is present
+
+        # the red dot moves when the touch is moving
+        win.dispatch(
+            'on_mouse_move',
+            50, self.correct_y(win, 50),
+            {}
+        )
+        self.assertEqual(
+            ellipse.pos,
+            (40, 40)
+        )  # bounding box from Rectangle, R=10 -> 20 width
+
+        # the dot is removed after the touch is released
+        # when right - touch is preserved -> dot remains
+        # when left  - touch is destroyed -> dot removed
+        win.dispatch(
+            'on_mouse_up',
+            10, self.correct_y(win, 10),
+            button, {}
+        )  # no matter where
+        self.assertEqual(mouse.counter, 1)
+
+        if button == 'left':
+            self.assertNotIn(event_id, mouse.touches)
+        elif button == 'right':
+            self.assertIn(event_id, mouse.touches)
+            self.assertIsNotNone(
+                mouse.touches[event_id].ud.get('_drawelement')
+            )  # the red dot is present
+
+        self.render(wid)
+
+        # cleanup!
+        # remove mouse provider
+        mouse.stop()
+        eventloop.remove_input_provider(mouse)
+
+    # tests
+    def test_multitouch_dontappear(self):
+        eventloop, win, mouse, wid = self.mouse_init()
+
+        # register mouse provider
+        mouse.start()
+        eventloop.add_input_provider(mouse)
+
+        # no mouse touch anywhere
+        self.assertEqual(mouse.counter, 0)
+        self.assertEqual(mouse.touches, {})
+
+        # left button down
+        win.dispatch(
+            'on_mouse_down',
+            10, self.correct_y(win, 10),
+            'left', {}
+        )
+        event_id = next(iter(mouse.touches))
+        win.dispatch(
+            'on_mouse_move',
+            11, self.correct_y(win, 11),
+            {}
+        )
+        self.assertEqual(mouse.counter, 1)
+        self.assertIsNone(
+            mouse.touches[event_id].ud.get('_drawelement')
+        )  # the red dot isn't present
+
+        # left button up
+        win.dispatch(
+            'on_mouse_up',
+            10, self.correct_y(win, 10),
+            'left', {}
+        )
+        # after the releasing the touch disappears,
+        # but the counter remains
+        self.assertEqual(mouse.counter, 1)
+        self.assertNotIn(event_id, mouse.touches)
+
+        self.advance_frames(1)
+        self.render(wid)
+
+        # cleanup!
+        # remove mouse provider
+        mouse.stop()
+        eventloop.remove_input_provider(mouse)
+
+    def test_multitouch_appear(self):
+        eventloop, win, mouse, wid = self.mouse_init()
+
+        # register mouse provider
+        mouse.start()
+        eventloop.add_input_provider(mouse)
+
+        # no mouse touch anywhere
+        self.assertEqual(mouse.counter, 0)
+        self.assertEqual(mouse.touches, {})
+
+        # right button down, red dot should appear
+        win.dispatch(
+            'on_mouse_down',
+            10, self.correct_y(win, 10),
+            'right', {}
+        )
+        event_id = next(iter(mouse.touches))
+        self.assertEqual(mouse.counter, 1)
+        self.assertIsNotNone(
+            mouse.touches[event_id].ud.get('_drawelement')
+        )  # the red dot is present
+
+        # do NOT make any hard refs to '_drawelement'
+        ellipse = mouse.touches[
+            event_id
+        ].ud.get('_drawelement')[1].proxy_ref
+
+        # check ellipse's position
+        self.assertAlmostEqual(ellipse.pos[0], 0, delta=0.0001)
+        # bounding box from Rectangle, R=10 -> 20 width
+        # almost equal because the correct_y uses the same
+        # float - float, which returns decimal garbage
+        self.assertAlmostEqual(ellipse.pos[1], 0, delta=0.0001)
+
+        win.dispatch(
+            'on_mouse_move',
+            11, self.correct_y(win, 11),
+            {}
+        )
+        # the red dot moves when the touch is moving
+        self.assertEqual(
+            ellipse.pos,
+            (1, 1)
+        )  # bounding box from Rectangle, R=10 -> 20 width
+        win.dispatch(
+            'on_mouse_up',
+            10, self.correct_y(win, 10),
+            'right', {}
+        )
+
+        self.assertEqual(
+            ellipse.pos,
+            (1, 1)
+        )  # bounding box from Rectangle, R=10 -> 20 width
+        self.assertEqual(mouse.counter, 1)
+        # because the red dot is removed by the left button
+        self.assertIn(event_id, mouse.touches)
+        self.assertIsNotNone(
+            mouse.touches[event_id].ud.get('_drawelement')
+        )  # the red dot is present
+
+        self.render(wid)
+
+        # cleanup!
+        # remove mouse provider
+        mouse.stop()
+        eventloop.remove_input_provider(mouse)
+
+    def test_multitouch_dot_lefttouch(self):
+        self.multitouch_dot_touch('left')
+
+    def test_multitouch_dot_leftmove(self):
+        self.multitouch_dot_move('left')
+
+    def test_multitouch_dot_righttouch(self):
+        self.multitouch_dot_touch('right')
+
+    def test_multitouch_dot_rightmove(self):
+        self.multitouch_dot_move('right')
+
+    def test_multitouch_on_demand_noscatter_lefttouch(self):
+        self.multitouch_dot_touch('left', on_demand=True)
+
+    def test_multitouch_on_demand_noscatter_leftmove(self):
+        self.multitouch_dot_move('left', on_demand=True)
+
+    def test_multitouch_on_demand_noscatter_righttouch(self):
+        self.multitouch_dot_touch('right', on_demand=True)
+
+    def test_multitouch_on_demand_noscatter_rightmove(self):
+        self.multitouch_dot_move('right', on_demand=True)
+
+    def test_multitouch_on_demand_scatter_lefttouch(self):
+        self.multitouch_dot_touch(
+            'left', on_demand=True, scatter=True
+        )
+
+    def test_multitouch_on_demand_scatter_leftmove(self):
+        self.multitouch_dot_move(
+            'left', on_demand=True, scatter=True
+        )
+
+    def test_multitouch_on_demand_scatter_righttouch(self):
+        self.multitouch_dot_touch(
+            'right', on_demand=True, scatter=True
+        )
+
+    def test_multitouch_on_demand_scatter_rightmove(self):
+        self.multitouch_dot_move(
+            'right', on_demand=True, scatter=True
+        )
+
+    def test_multitouch_disabled_lefttouch(self):
+        self.multitouch_dot_touch('left', disabled=True)
+
+    def test_multitouch_disabled_leftmove(self):
+        self.multitouch_dot_move('left', disabled=True)
+
+    def test_multitouch_disabled_righttouch(self):
+        self.multitouch_dot_touch('right', disabled=True)
+
+    def test_multitouch_disabled_rightmove(self):
+        self.multitouch_dot_move('right', disabled=True)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_multistroke.py b/kivy/tests/test_multistroke.py
new file mode 100644
index 0000000..ee2e2e3
--- /dev/null
+++ b/kivy/tests/test_multistroke.py
@@ -0,0 +1,389 @@
+import pytest
+import unittest
+import kivy.multistroke
+from kivy.multistroke import Recognizer, MultistrokeGesture
+from kivy.vector import Vector
+
+best_score = 0.0
+counter = 0
+
+
+def best_score_cb(result):
+    global best_score
+    best_score = result.best['score']
+
+
+def counter_cb(result):
+    global counter
+    counter += 1
+
+
+# These are taken from the examples in JavaScript code (but made unistrokes)
+TGesture = [Vector(30, 7), Vector(103, 7), Vector(66, 7), Vector(66, 87)]
+NGesture = [Vector(177, 92), Vector(177, 2), Vector(182, 1), Vector(246, 95),
+             Vector(247, 87), Vector(247, 1)]
+
+
+# dataset that matches N pretty well
+Ncandidate = [
+    Vector(160, 271), Vector(160, 263), Vector(158, 257), Vector(156, 249),
+    Vector(146, 187), Vector(144, 181), Vector(144, 175), Vector(142, 167),
+    Vector(140, 113), Vector(140, 107), Vector(140, 103), Vector(140, 99),
+    Vector(140, 85), Vector(138, 85), Vector(138, 87), Vector(138, 89),
+    Vector(166, 151), Vector(176, 171), Vector(188, 189), Vector(200, 205),
+    Vector(238, 263), Vector(242, 269), Vector(244, 273), Vector(246, 277),
+    Vector(252, 289), Vector(254, 291), Vector(256, 291), Vector(258, 291),
+    Vector(260, 281), Vector(260, 275), Vector(260, 267), Vector(260, 255),
+    Vector(254, 189), Vector(254, 175), Vector(254, 161), Vector(254, 147),
+    Vector(260, 103), Vector(260, 101), Vector(260, 99), Vector(260, 95),
+    Vector(260, 93), Vector(260, 91), Vector(260, 89)
+]
+
+
+class MultistrokeTestCase(unittest.TestCase):
+
+    def setUp(self):
+        global best_score
+        best_score = 0
+        counter = 0
+
+        self.Tinvar = MultistrokeGesture('T', [TGesture],
+            orientation_sensitive=False)
+        self.Tbound = MultistrokeGesture('T', [TGesture],
+            orientation_sensitive=True)
+        self.Ninvar = MultistrokeGesture('N', [NGesture],
+            orientation_sensitive=False)
+        self.Nbound = MultistrokeGesture('N', [NGesture],
+            orientation_sensitive=True)
+
+    @pytest.fixture(autouse=True)
+    def set_clock(self, kivy_clock):
+        self.kivy_clock = kivy_clock
+
+# -----------------------------------------------------------------------------
+# Recognizer scheduling
+# -----------------------------------------------------------------------------
+    def test_immediate(self):
+        gdb = Recognizer(db=[self.Tinvar, self.Ninvar])
+        r = gdb.recognize([Ncandidate], max_gpf=0)
+        self.assertEqual(r._match_ops, 4)
+        self.assertEqual(r._completed, 2)
+        self.assertEqual(r.progress, 1)
+        self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
+
+    def test_scheduling(self):
+        global best_score
+        from kivy.clock import Clock
+        gdb = Recognizer(db=[self.Tinvar, self.Ninvar])
+        r = gdb.recognize([Ncandidate], max_gpf=1)
+        r.bind(on_complete=best_score_cb)
+
+        # _recognize_tick is scheduled here; compares to Tinvar
+        Clock.tick()
+        self.assertEqual(r.progress, .5)
+        self.assertEqual(best_score, .0)
+
+        # Now complete the search operation
+        Clock.tick()
+        self.assertEqual(r.progress, 1)
+        self.assertTrue(best_score > 0.94 and best_score < 0.95)
+
+    def test_scheduling_limits(self):
+        global best_score
+        from kivy.clock import Clock
+        gdb = Recognizer(db=[self.Ninvar])
+        tpls = len(self.Ninvar.templates)
+
+        best_score = 0
+        gdb.db.append(self.Ninvar)
+        r = gdb.recognize([Ncandidate], max_gpf=1)
+        r.bind(on_complete=best_score_cb)
+        self.assertEqual(r.progress, 0)
+        Clock.tick()
+        self.assertEqual(r.progress, 0.5)
+        self.assertEqual(best_score, 0)
+        Clock.tick()
+        self.assertEqual(r.progress, 1)
+        self.assertTrue(best_score > 0.94 and best_score < 0.95)
+
+        best_score = 0
+        gdb.db.append(self.Ninvar)
+        r = gdb.recognize([Ncandidate], max_gpf=1)
+        r.bind(on_complete=best_score_cb)
+        self.assertEqual(r.progress, 0)
+        Clock.tick()
+        self.assertEqual(r.progress, 1 / 3.)
+
+        Clock.tick()
+        self.assertEqual(r.progress, 2 / 3.)
+        self.assertEqual(best_score, 0)
+
+        Clock.tick()
+        self.assertEqual(r.progress, 1)
+        self.assertTrue(best_score > 0.94 and best_score < 0.95)
+
+    def test_parallel_recognize(self):
+        global counter
+        from kivy.clock import Clock
+
+        counter = 0
+        gdb = Recognizer()
+        for i in range(9):
+            gdb.add_gesture('T', [TGesture], priority=50)
+        gdb.add_gesture('N', [NGesture])
+
+        r1 = gdb.recognize([Ncandidate], max_gpf=1)
+        r1.bind(on_complete=counter_cb)
+        Clock.tick()  # first run scheduled here; 9 left
+
+        r2 = gdb.recognize([Ncandidate], max_gpf=1)
+        r2.bind(on_complete=counter_cb)
+        Clock.tick()  # 8 left
+
+        r3 = gdb.recognize([Ncandidate], max_gpf=1)
+        r3.bind(on_complete=counter_cb)
+        Clock.tick()  # 7 left
+
+        # run some immediate searches, should not interfere.
+        for i in range(5):
+            n = gdb.recognize([TGesture], max_gpf=0)
+            self.assertEqual(n.best['name'], 'T')
+            self.assertTrue(round(n.best['score'], 1) == 1.0)
+
+        for i in range(6):
+            Clock.tick()
+        self.assertEqual(counter, 0)
+        Clock.tick()
+        self.assertEqual(counter, 1)
+        Clock.tick()
+        self.assertEqual(counter, 2)
+        Clock.tick()
+        self.assertEqual(counter, 3)
+
+    def test_timeout_case_1(self):
+        global best_score
+        from kivy.clock import Clock
+        from time import sleep
+
+        best_score = 0
+        gdb = Recognizer(db=[self.Tbound, self.Ninvar])
+        r = gdb.recognize([Ncandidate], max_gpf=1, timeout=0.4)
+        Clock.tick()  # matches Tbound in this tick
+        self.assertEqual(best_score, 0)
+        sleep(0.4)
+        Clock.tick()  # should match Ninv, but times out (got T)
+        self.assertEqual(r.status, 'timeout')
+        self.assertEqual(r.progress, .5)
+        self.assertTrue(r.best['name'] == 'T')
+        self.assertTrue(r.best['score'] < 0.5)
+
+    def test_timeout_case_2(self):
+        global best_score
+        from kivy.clock import Clock
+        from time import sleep
+
+        best_score = 0
+        gdb = Recognizer(db=[self.Tbound, self.Ninvar, self.Tinvar])
+        r = gdb.recognize([Ncandidate], max_gpf=1, timeout=0.8)
+
+        Clock.tick()  # matches Tbound in this tick
+        self.assertEqual(best_score, 0)
+        sleep(0.4)
+        Clock.tick()  # matches Ninvar in this tick
+        sleep(0.4)
+        Clock.tick()  # should match Tinvar, but times out
+        self.assertEqual(r.status, 'timeout')
+        self.assertEqual(r.progress, 2 / 3.)
+        self.assertTrue(r.best['score'] >= .94 and r.best['score'] <= .95)
+
+    def test_priority_sorting(self):
+        gdb = Recognizer()
+        gdb.add_gesture('N', [NGesture], priority=10)
+        gdb.add_gesture('T', [TGesture], priority=5)
+
+        r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
+                        force_priority_sort=True)
+        self.assertEqual(r.best['name'], 'T')
+
+        r = gdb.recognize([Ncandidate], goodscore=0.01,
+                        force_priority_sort=False, max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+
+        r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
+                        priority=10)
+        self.assertEqual(r.best['name'], 'T')
+
+        r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
+                        priority=4)
+        self.assertEqual(r.best['name'], None)
+
+# -----------------------------------------------------------------------------
+# Recognizer - filter tests
+# -----------------------------------------------------------------------------
+    def test_name_filter(self):
+        gdb = Recognizer(db=[self.Ninvar, self.Nbound])
+        n = gdb.filter()
+        self.assertEqual(len(n), 2)
+        n = gdb.filter(name='X')
+        self.assertEqual(len(n), 0)
+
+    def test_numpoints_filter(self):
+        gdb = Recognizer(db=[self.Ninvar, self.Nbound])
+        n = gdb.filter(numpoints=100)
+        self.assertEqual(len(n), 0)
+
+        gdb.add_gesture('T', [TGesture], numpoints=100)
+        n = gdb.filter(numpoints=100)
+        self.assertEqual(len(n), 1)
+        n = gdb.filter(numpoints=[100, 16])
+        self.assertEqual(len(n), 3)
+
+    def test_numstrokes_filter(self):
+        gdb = Recognizer(db=[self.Ninvar, self.Nbound])
+        n = gdb.filter(numstrokes=2)
+        self.assertEqual(len(n), 0)
+
+        gdb.add_gesture('T', [TGesture, TGesture])
+        n = gdb.filter(numstrokes=2)
+        self.assertEqual(len(n), 1)
+        n = gdb.filter(numstrokes=[1, 2])
+        self.assertEqual(len(n), 3)
+
+    def test_priority_filter(self):
+        gdb = Recognizer(db=[self.Ninvar, self.Nbound])
+        n = gdb.filter(priority=50)
+        self.assertEqual(len(n), 0)
+
+        gdb.add_gesture('T', [TGesture], priority=51)
+        n = gdb.filter(priority=50)
+        self.assertEqual(len(n), 0)
+        n = gdb.filter(priority=51)
+        self.assertEqual(len(n), 1)
+
+        gdb.add_gesture('T', [TGesture], priority=52)
+        n = gdb.filter(priority=[0, 51])
+        self.assertEqual(len(n), 1)
+        n = gdb.filter(priority=[0, 52])
+        self.assertEqual(len(n), 2)
+        n = gdb.filter(priority=[51, 52])
+        self.assertEqual(len(n), 2)
+        n = gdb.filter(priority=[52, 53])
+        self.assertEqual(len(n), 1)
+        n = gdb.filter(priority=[53, 54])
+        self.assertEqual(len(n), 0)
+
+    def test_orientation_filter(self):
+        gdb = Recognizer(db=[self.Ninvar, self.Nbound])
+        n = gdb.filter(orientation_sensitive=True)
+        self.assertEqual(len(n), 1)
+        n = gdb.filter(orientation_sensitive=False)
+        self.assertEqual(len(n), 1)
+        n = gdb.filter(orientation_sensitive=None)
+        self.assertEqual(len(n), 2)
+
+        gdb.db.append(self.Tinvar)
+        n = gdb.filter(orientation_sensitive=True)
+        self.assertEqual(len(n), 1)
+        n = gdb.filter(orientation_sensitive=False)
+        self.assertEqual(len(n), 2)
+        n = gdb.filter(orientation_sensitive=None)
+        self.assertEqual(len(n), 3)
+
+# -----------------------------------------------------------------------------
+# misc tests
+# -----------------------------------------------------------------------------
+    def test_resample(self):
+        r = kivy.multistroke.resample([Vector(0, 0), Vector(1, 1)], 11)
+        self.assertEqual(len(r), 11)
+        self.assertEqual(round(r[9].x, 1), 0.9)
+
+        r = kivy.multistroke.resample(TGesture, 25)
+        self.assertEqual(len(r), 25)
+        self.assertEqual(round(r[12].x), 81)
+        self.assertEqual(r[12].y, 7)
+        self.assertEqual(TGesture[3].x, r[24].x)
+        self.assertEqual(TGesture[3].y, r[24].y)
+
+    def test_rotateby(self):
+        r = kivy.multistroke.rotate_by(NGesture, 24)
+        self.assertEqual(round(r[2].x, 1), 158.59999999999999)
+        self.assertEqual(round(r[2].y, 1), 54.899999999999999)
+
+    def test_transfer(self):
+        gdb1 = Recognizer(db=[self.Ninvar])
+        gdb2 = Recognizer()
+        gdb1.transfer_gesture(gdb2, name='N')
+
+        r = gdb2.recognize([Ncandidate], max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+        self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
+
+    def test_export_import_case_1(self):
+        gdb1 = Recognizer(db=[self.Ninvar])
+        gdb2 = Recognizer()
+
+        g = gdb1.export_gesture(name='N')
+        gdb2.import_gesture(g)
+
+        r = gdb2.recognize([Ncandidate], max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+        self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
+
+    def test_export_import_case_2(self):
+        from tempfile import mkstemp
+        import os
+        gdb1 = Recognizer(db=[self.Ninvar, self.Tinvar])
+        gdb2 = Recognizer()
+        fh, fn = mkstemp()
+        os.close(fh)
+        g = gdb1.export_gesture(name='N', filename=fn)
+
+        gdb2.import_gesture(filename=fn)
+        os.unlink(fn)
+
+        self.assertEqual(len(gdb1.db), 2)
+        self.assertEqual(len(gdb2.db), 1)
+        r = gdb2.recognize([Ncandidate], max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+        self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
+
+# ------------------------------------------------------------------------
+# Test protractor
+# ------------------------------------------------------------------------
+    def test_protractor_invariant(self):
+        gdb = Recognizer(db=[self.Tinvar, self.Ninvar])
+        r = gdb.recognize([NGesture], orientation_sensitive=False,
+            max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+        self.assertTrue(r.best['score'] == 1.0)
+
+        r = gdb.recognize([NGesture], orientation_sensitive=True,
+            max_gpf=0)
+        self.assertEqual(r.best['name'], None)
+        self.assertEqual(r.best['score'], 0)
+
+        r = gdb.recognize([Ncandidate], orientation_sensitive=False,
+            max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+        self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
+
+    def test_protractor_bound(self):
+        gdb = Recognizer(db=[self.Tbound, self.Nbound])
+        r = gdb.recognize([NGesture], orientation_sensitive=True,
+            max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+        self.assertTrue(r.best['score'] >= 0.99)
+
+        r = gdb.recognize([NGesture], orientation_sensitive=False,
+            max_gpf=0)
+        self.assertEqual(r.best['name'], None)
+        self.assertEqual(r.best['score'], 0)
+
+        r = gdb.recognize([Ncandidate], orientation_sensitive=True,
+            max_gpf=0)
+        self.assertEqual(r.best['name'], 'N')
+        self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/kivy/tests/test_properties.py b/kivy/tests/test_properties.py
new file mode 100644
index 0000000..9e215d6
--- /dev/null
+++ b/kivy/tests/test_properties.py
@@ -0,0 +1,1332 @@
+'''
+Test properties attached to a widget
+'''
+
+import unittest
+import pytest
+from kivy.event import EventDispatcher
+from functools import partial
+
+
+class _TestProperty(EventDispatcher):
+    pass
+
+
+wid = _TestProperty()
+
+
+@pytest.fixture(autouse=True)
+def set_clock(kivy_clock):
+    pass
+
+
+@pytest.fixture()
+def self():
+    return unittest.TestCase()
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_base(self, set_name):
+    from kivy.properties import Property
+
+    a = Property(-1)
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), -1)
+    a.set(wid, 0)
+    self.assertEqual(a.get(wid), 0)
+    a.set(wid, 1)
+    self.assertEqual(a.get(wid), 1)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_observer(self, set_name):
+    from kivy.properties import Property
+
+    a = Property(-1)
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), -1)
+    global observe_called
+    observe_called = 0
+
+    def observe(obj, value):
+        global observe_called
+        observe_called = 1
+    a.bind(wid, observe)
+
+    a.set(wid, 0)
+    self.assertEqual(a.get(wid), 0)
+    self.assertEqual(observe_called, 1)
+    observe_called = 0
+    a.set(wid, 0)
+    self.assertEqual(a.get(wid), 0)
+    self.assertEqual(observe_called, 0)
+    a.set(wid, 1)
+    self.assertEqual(a.get(wid), 1)
+    self.assertEqual(observe_called, 1)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_objectcheck(self, set_name):
+    from kivy.properties import ObjectProperty
+
+    a = ObjectProperty(False)
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), False)
+    a.set(wid, True)
+    self.assertEqual(a.get(wid), True)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_stringcheck(self, set_name):
+    from kivy.properties import StringProperty
+
+    a = StringProperty()
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), '')
+    a.set(wid, 'hello')
+    self.assertEqual(a.get(wid), 'hello')
+
+    try:
+        a.set(wid, 88)  # number shouldn't be accepted
+        self.fail('string accept number, fail.')
+    except ValueError:
+        pass
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_numericcheck(self, set_name):
+    from kivy.properties import NumericProperty
+
+    a = NumericProperty()
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), 0)
+    a.set(wid, 99)
+    self.assertEqual(a.get(wid), 99)
+
+    # try:
+    #    a.set(wid, '')  # string shouldn't be accepted
+    #    self.fail('number accept string, fail.')
+    # except ValueError:
+    #    pass
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_listcheck(self, set_name):
+    from kivy.properties import ListProperty
+
+    a = ListProperty()
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), [])
+    a.set(wid, [1, 2, 3])
+    self.assertEqual(a.get(wid), [1, 2, 3])
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_dictcheck(self, set_name):
+    from kivy.properties import DictProperty
+
+    a = DictProperty()
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), {})
+    a.set(wid, {'foo': 'bar'})
+    self.assertEqual(a.get(wid), {'foo': 'bar'})
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_propertynone(self, set_name):
+    from kivy.properties import NumericProperty
+
+    a = NumericProperty(0, allownone=True)
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), 0)
+    try:
+        a.set(wid, None)
+        self.assertEqual(a.get(wid), None)
+    except ValueError:
+        pass
+    a.set(wid, 1)
+    self.assertEqual(a.get(wid), 1)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_reference(self, set_name):
+    from kivy.properties import NumericProperty, ReferenceListProperty
+
+    x = NumericProperty(0)
+    if set_name:
+        x.set_name(wid, 'x')
+        x.link_eagerly(wid)
+    else:
+        x.link(wid, 'x')
+        x.link_deps(wid, 'x')
+    y = NumericProperty(0)
+    if set_name:
+        y.set_name(wid, 'y')
+        y.link_eagerly(wid)
+    else:
+        y.link(wid, 'y')
+        y.link_deps(wid, 'y')
+    pos = ReferenceListProperty(x, y)
+    if set_name:
+        pos.set_name(wid, 'pos')
+        pos.link_eagerly(wid)
+    else:
+        pos.link(wid, 'pos')
+        pos.link_deps(wid, 'pos')
+
+    self.assertEqual(x.get(wid), 0)
+    self.assertEqual(y.get(wid), 0)
+    self.assertEqual(pos.get(wid), [0, 0])
+
+    x.set(wid, 50)
+    self.assertEqual(pos.get(wid), [50, 0])
+
+    y.set(wid, 50)
+    self.assertEqual(pos.get(wid), [50, 50])
+
+    pos.set(wid, [0, 0])
+    self.assertEqual(pos.get(wid), [0, 0])
+    self.assertEqual(x.get(wid), 0)
+    self.assertEqual(y.get(wid), 0)
+
+    # test observer
+    global observe_called
+    observe_called = 0
+
+    def observe(obj, value):
+        global observe_called
+        observe_called = 1
+    pos.bind(wid, observe)
+
+    self.assertEqual(observe_called, 0)
+    x.set(wid, 99)
+    self.assertEqual(observe_called, 1)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_reference_child_update(self, set_name):
+    from kivy.properties import NumericProperty, ReferenceListProperty
+
+    x = NumericProperty(0)
+    if set_name:
+        x.set_name(wid, 'x')
+        x.link_eagerly(wid)
+    else:
+        x.link(wid, 'x')
+        x.link_deps(wid, 'x')
+    y = NumericProperty(0)
+    if set_name:
+        y.set_name(wid, 'y')
+        y.link_eagerly(wid)
+    else:
+        y.link(wid, 'y')
+        y.link_deps(wid, 'y')
+    pos = ReferenceListProperty(x, y)
+    if set_name:
+        pos.set_name(wid, 'pos')
+        pos.link_eagerly(wid)
+    else:
+        pos.link(wid, 'pos')
+        pos.link_deps(wid, 'pos')
+
+    pos.get(wid)[0] = 10
+    self.assertEqual(pos.get(wid), [10, 0])
+
+    pos.get(wid)[:] = (20, 30)
+    self.assertEqual(pos.get(wid), [20, 30])
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_dict(self, set_name):
+    from kivy.properties import DictProperty
+
+    x = DictProperty()
+    if set_name:
+        x.set_name(wid, 'x')
+        x.link_eagerly(wid)
+    else:
+        x.link(wid, 'x')
+        x.link_deps(wid, 'x')
+
+    # test observer
+    global observe_called
+    observe_called = 0
+
+    def observe(obj, value):
+        global observe_called
+        observe_called = 1
+
+    x.bind(wid, observe)
+
+    observe_called = 0
+    x.get(wid)['toto'] = 1
+    self.assertEqual(observe_called, 1)
+
+    observe_called = 0
+    x.get(wid)['toto'] = 2
+    self.assertEqual(observe_called, 1)
+
+    observe_called = 0
+    x.get(wid)['youupi'] = 2
+    self.assertEqual(observe_called, 1)
+
+    observe_called = 0
+    del x.get(wid)['toto']
+    self.assertEqual(observe_called, 1)
+
+    observe_called = 0
+    x.get(wid).update({'bleh': 5})
+    self.assertEqual(observe_called, 1)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_bounded_numeric_property(self, set_name):
+    from kivy.properties import BoundedNumericProperty
+
+    bnp = BoundedNumericProperty(0.0, min=0.0, max=3.5)
+
+    if set_name:
+        bnp.set_name(wid, 'bnp')
+        bnp.link_eagerly(wid)
+    else:
+        bnp.link(wid, 'bnp')
+        bnp.link_deps(wid, 'bnp')
+
+    bnp.set(wid, 1)
+    bnp.set(wid, 0.0)
+    bnp.set(wid, 3.1)
+    bnp.set(wid, 3.5)
+    self.assertRaises(ValueError, partial(bnp.set, wid, 3.6))
+    self.assertRaises(ValueError, partial(bnp.set, wid, -3))
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_bounded_numeric_property_error_value(self, set_name):
+    from kivy.properties import BoundedNumericProperty
+
+    bnp = BoundedNumericProperty(0, min=-5, max=5, errorvalue=1)
+    if set_name:
+        bnp.set_name(wid, 'bnp')
+        bnp.link_eagerly(wid)
+    else:
+        bnp.link(wid, 'bnp')
+        bnp.link_deps(wid, 'bnp')
+
+    bnp.set(wid, 1)
+    self.assertEqual(bnp.get(wid), 1)
+
+    bnp.set(wid, 5)
+    self.assertEqual(bnp.get(wid), 5)
+
+    bnp.set(wid, 6)
+    self.assertEqual(bnp.get(wid), 1)
+
+    bnp.set(wid, -5)
+    self.assertEqual(bnp.get(wid), -5)
+
+    bnp.set(wid, -6)
+    self.assertEqual(bnp.get(wid), 1)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_bounded_numeric_property_error_handler(self, set_name):
+    from kivy.properties import BoundedNumericProperty
+
+    bnp = BoundedNumericProperty(
+        0, min=-5, max=5,
+        errorhandler=lambda x: 5 if x > 5 else -5)
+
+    if set_name:
+        bnp.set_name(wid, 'bnp')
+        bnp.link_eagerly(wid)
+    else:
+        bnp.link(wid, 'bnp')
+        bnp.link_deps(wid, 'bnp')
+
+    bnp.set(wid, 1)
+    self.assertEqual(bnp.get(wid), 1)
+
+    bnp.set(wid, 5)
+    self.assertEqual(bnp.get(wid), 5)
+
+    bnp.set(wid, 10)
+    self.assertEqual(bnp.get(wid), 5)
+
+    bnp.set(wid, -5)
+    self.assertEqual(bnp.get(wid), -5)
+
+    bnp.set(wid, -10)
+    self.assertEqual(bnp.get(wid), -5)
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_numeric_string_with_units_check(self, set_name):
+    from kivy.properties import NumericProperty
+    from kivy.metrics import Metrics
+
+    a = NumericProperty()
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), 0)
+
+    a.set(wid, '55dp')
+    density = Metrics.density
+    self.assertEqual(a.get(wid), 55 * density)
+    self.assertEqual(a.get_format(wid), 'dp')
+
+    a.set(wid, u'55dp')
+    self.assertEqual(a.get(wid), 55 * density)
+    self.assertEqual(a.get_format(wid), 'dp')
+
+    a.set(wid, '99in')
+    self.assertEqual(a.get(wid), 9504.0 * density)
+    self.assertEqual(a.get_format(wid), 'in')
+
+    a.set(wid, u'99in')
+    self.assertEqual(a.get(wid), 9504.0 * density)
+    self.assertEqual(a.get_format(wid), 'in')
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_numeric_string_without_units(self, set_name):
+    from kivy.properties import NumericProperty
+
+    a = NumericProperty()
+    if set_name:
+        a.set_name(wid, 'a')
+        a.link_eagerly(wid)
+    else:
+        a.link(wid, 'a')
+        a.link_deps(wid, 'a')
+    self.assertEqual(a.get(wid), 0)
+
+    a.set(wid, '2')
+    self.assertEqual(a.get(wid), 2)
+
+
+def test_property_rebind(self):
+    from kivy.uix.label import Label
+    from kivy.uix.togglebutton import ToggleButton
+    from kivy.lang import Builder
+    from kivy.properties import ObjectProperty, DictProperty, AliasProperty
+    from kivy.clock import Clock
+
+    class ObjWidget(Label):
+        button = ObjectProperty(None, rebind=True, allownone=True)
+
+    class ObjWidgetRebindFalse(Label):
+        button = ObjectProperty(None, rebind=False, allownone=True)
+
+    class DictWidget(Label):
+        button = DictProperty({'button': None}, rebind=True,
+                              allownone=True)
+
+    class DictWidgetFalse(Label):
+        button = DictProperty({'button': None}, rebind=False)
+
+    class AliasWidget(Label):
+        _button = None
+
+        def setter(self, value):
+            self._button = value
+            return True
+
+        def getter(self):
+            return self._button
+        button = AliasProperty(getter, setter, rebind=True)
+
+    Builder.load_string('''
+<ObjWidget>:
+    text: self.button.state if self.button is not None else 'Unset'
+
+<ObjWidgetRebindFalse>:
+    text: self.button.state if self.button is not None else 'Unset'
+
+<AliasWidget>:
+    text: self.button.state if self.button is not None else 'Unset'
+
+<DictWidget>:
+    text: self.button.button.state if self.button.button is not None\
+ else 'Unset'
+
+<DictWidgetFalse>:
+    text: self.button.button.state if self.button.button is not None\
+ else 'Unset'
+''')
+
+    obj = ObjWidget()
+    obj_false = ObjWidgetRebindFalse()
+    dict_rebind = DictWidget()
+    dict_false = DictWidgetFalse()
+    alias_rebind = AliasWidget()
+    button = ToggleButton()
+    Clock.tick()
+    self.assertEqual(obj.text, 'Unset')
+    self.assertEqual(obj_false.text, 'Unset')
+    self.assertEqual(dict_rebind.text, 'Unset')
+    self.assertEqual(dict_false.text, 'Unset')
+    self.assertEqual(alias_rebind.text, 'Unset')
+
+    obj.button = button
+    obj_false.button = button
+    dict_rebind.button.button = button
+    dict_false.button.button = button
+    alias_rebind.button = button
+    Clock.tick()
+    self.assertEqual(obj.text, 'normal')
+    self.assertEqual(obj_false.text, 'normal')
+    self.assertEqual(dict_rebind.text, 'normal')
+    self.assertEqual(dict_false.text, 'Unset')
+    self.assertEqual(alias_rebind.text, 'normal')
+
+    button.state = 'down'
+    Clock.tick()
+    self.assertEqual(obj.text, 'down')
+    self.assertEqual(obj_false.text, 'normal')
+    self.assertEqual(dict_rebind.text, 'down')
+    self.assertEqual(dict_false.text, 'Unset')
+    self.assertEqual(alias_rebind.text, 'down')
+
+    button.state = 'normal'
+    Clock.tick()
+    self.assertEqual(obj.text, 'normal')
+    self.assertEqual(obj_false.text, 'normal')
+    self.assertEqual(dict_rebind.text, 'normal')
+    self.assertEqual(dict_false.text, 'Unset')
+    self.assertEqual(alias_rebind.text, 'normal')
+
+    obj.button = None
+    obj_false.button = None
+    dict_rebind.button.button = None
+    dict_false.button.button = None
+    alias_rebind.button = None
+    Clock.tick()
+    self.assertEqual(obj.text, 'Unset')
+    self.assertEqual(obj_false.text, 'Unset')
+    self.assertEqual(dict_rebind.text, 'Unset')
+    self.assertEqual(dict_false.text, 'Unset')
+    self.assertEqual(alias_rebind.text, 'Unset')
+
+
+@pytest.mark.parametrize('set_name', [True, False])
+def test_color_property(self, set_name):
+    from kivy.properties import ColorProperty
+
+    color = ColorProperty()
+    if set_name:
+        color.set_name(wid, 'color')
+        color.link_eagerly(wid)
+    else:
+        color.link(wid, 'color')
+        color.link_deps(wid, 'color')
+    self.assertEqual(color.get(wid), [1, 1, 1, 1])
+
+    color2 = ColorProperty()
+    if set_name:
+        color2.set_name(wid, 'color2')
+        color2.link_eagerly(wid)
+    else:
+        color2.link(wid, 'color2')
+        color2.link_deps(wid, 'color2')
+    self.assertEqual(color2.get(wid), [1, 1, 1, 1])
+
+    color.set(wid, 'yellow')
+    self.assertEqual(color.get(wid), [1.0, 1.0, 0.0, 1.0])
+
+    color.set(wid, "#00ff00")
+    self.assertEqual(color.get(wid), [0, 1, 0, 1])
+
+    color.set(wid, "#7f7fff7f")
+    self.assertEqual(color.get(wid)[0], 127 / 255.)
+    self.assertEqual(color.get(wid)[1], 127 / 255.)
+    self.assertEqual(color.get(wid)[2], 1)
+    self.assertEqual(color.get(wid)[3], 127 / 255.)
+
+    color.set(wid, (1, 1, 0))
+    self.assertEqual(color.get(wid), [1, 1, 0, 1])
+    color.set(wid, (1, 1, 0, 0))
+    self.assertEqual(color.get(wid), [1, 1, 0, 0])
+
+    color.set(wid, [1, 1, 1, 1])
+    color_value = color.get(wid)
+    color_value[0] = 0.5
+    self.assertEqual(color.get(wid), [0.5, 1, 1, 1])
+
+    self.assertEqual(color2.get(wid), [1, 1, 1, 1])
+    color2.set(wid, color.get(wid))
+    self.assertEqual(color2.get(wid), [0.5, 1, 1, 1])
+
+    color.set(wid, [1, 1, 1, 1])
+    color_value = color.get(wid)
+    color_value[:] = [0, 1, 0, 1]
+    self.assertEqual(color.get(wid), [0, 1, 0, 1])
+
+
+@pytest.mark.parametrize('watch_before_use', [True, False])
+def test_alias_property_without_setter(self, watch_before_use):
+    from kivy.properties import AliasProperty
+
+    expected_value = 5
+
+    class CustomAlias(EventDispatcher):
+
+        def _get_prop(self):
+            self.getter_called += 1
+            return expected_value
+
+        prop = AliasProperty(_get_prop, None, watch_before_use=watch_before_use)
+
+        def __init__(self, **kwargs):
+            super(CustomAlias, self).__init__(**kwargs)
+            self.getter_called = 0
+
+    # Initial checks
+    wid = CustomAlias()
+    self.assertEqual(wid.getter_called, 0)
+
+    # Get value, should call getter once
+    value = wid.prop
+    self.assertEqual(value, expected_value)
+    self.assertEqual(wid.getter_called, 1)
+
+    # Setter should raise an AttributeError
+    self.assertRaises(AttributeError, partial(setattr, wid, 'prop', 1))
+
+
+@pytest.mark.parametrize('watch_before_use', [True, False])
+def test_alias_property(self, watch_before_use):
+    from kivy.properties import AliasProperty
+
+    class CustomAlias(EventDispatcher):
+
+        def _get_prop(self):
+            self.getter_called += 1
+
+        def _set_prop(self, value):
+            self.setter_called += 1
+
+        prop = AliasProperty(
+            _get_prop, _set_prop, watch_before_use=watch_before_use)
+
+        def __init__(self, **kwargs):
+            super(CustomAlias, self).__init__(**kwargs)
+            self.getter_called = 0
+            self.setter_called = 0
+            self.callback_called = 0
+
+    def callback(widget, value):
+        widget.callback_called += 1
+
+    # Initial checks
+    wid = CustomAlias()
+    wid.bind(prop=callback)
+    self.assertEqual(wid.getter_called, 0)
+    self.assertEqual(wid.setter_called, 0)
+    self.assertEqual(wid.callback_called, 0)
+
+    # Set property, should call setter to set the value
+    # Getter and callback should not be called because `_set_prop` doesn't
+    # returns True
+    wid.prop = 1
+    self.assertEqual(wid.getter_called, 0)
+    self.assertEqual(wid.setter_called, 1)
+    self.assertEqual(wid.callback_called, 0)
+
+    # Set property to same value as before, should only call setter
+    wid.prop = 1
+    self.assertEqual(wid.getter_called, 0)
+    self.assertEqual(wid.setter_called, 2)
+    self.assertEqual(wid.callback_called, 0)
+
+    # Get value of the property, should call getter once
+    self.assertEqual(wid.prop, None)
+    self.assertEqual(wid.getter_called, 1)
+    self.assertEqual(wid.setter_called, 2)
+    self.assertEqual(wid.callback_called, 0)
+
+
+@pytest.mark.parametrize('watch_before_use', [True, False])
+def test_alias_property_cache_true(self, watch_before_use):
+    from kivy.properties import AliasProperty
+
+    expected_value = 5
+
+    class CustomAlias(EventDispatcher):
+
+        def _get_prop(self):
+            self.getter_called += 1
+            return expected_value
+
+        def _set_prop(self, value):
+            self.setter_called += 1
+            return True
+
+        prop = AliasProperty(
+            _get_prop, _set_prop, cache=True, watch_before_use=watch_before_use)
+
+        def __init__(self, **kwargs):
+            super(CustomAlias, self).__init__(**kwargs)
+            self.getter_called = 0
+            self.setter_called = 0
+
+    # Initial checks
+    wid = CustomAlias()
+    self.assertEqual(wid.getter_called, 0)
+    self.assertEqual(wid.setter_called, 0)
+
+    # Get value of the property, should call getter once
+    value = wid.prop
+    self.assertEqual(value, expected_value)
+    self.assertEqual(wid.getter_called, 1)
+    self.assertEqual(wid.setter_called, 0)
+
+    # Get value of the property, should return cached value
+    # Getter should not be called
+    value = wid.prop
+    self.assertEqual(value, expected_value)
+    self.assertEqual(wid.getter_called, 1)
+    self.assertEqual(wid.setter_called, 0)
+
+    # Set value of property, should call getter and setter
+    wid.prop = 10
+    value = wid.prop
+    self.assertEqual(value, expected_value)
+    self.assertEqual(wid.setter_called, 1)
+    self.assertEqual(wid.getter_called, 2)
+
+
+@pytest.mark.parametrize('watch_before_use', [True, False])
+def test_alias_property_with_bind(self, watch_before_use):
+    from kivy.properties import NumericProperty, AliasProperty
+
+    class CustomAlias(EventDispatcher):
+
+        x = NumericProperty(0)
+        width = NumericProperty(100)
+
+        def get_right(self):
+            return self.x + self.width
+
+        def set_right(self, value):
+            self.x = value - self.width
+
+        right = AliasProperty(
+            get_right, set_right, bind=('x', 'width'),
+            watch_before_use=watch_before_use)
+
+        def __init__(self, **kwargs):
+            super(CustomAlias, self).__init__(**kwargs)
+            self.callback_called = 0
+
+    # Assert values when setting x, width or right properties
+    wid = CustomAlias()
+    self.assertEqual(wid.right, 100)
+    wid.x = 500
+    self.assertEqual(wid.right, 600)
+    wid.width = 50
+    self.assertEqual(wid.right, 550)
+    wid.right = 100
+    self.assertEqual(wid.width, 50)
+    self.assertEqual(wid.x, 50)
+
+    def callback(widget, value):
+        widget.callback_called += 1
+
+    wid.bind(right=callback)
+
+    # Callback should be called only when property changes
+    wid.x = 100
+    self.assertEqual(wid.callback_called, 1)
+    wid.x = 100
+    self.assertEqual(wid.callback_called, 1)
+    wid.width = 900
+    self.assertEqual(wid.callback_called, 2)
+    wid.right = 700
+    self.assertEqual(wid.callback_called, 3)
+    wid.right = 700
+    self.assertEqual(wid.callback_called, 3)
+
+
+@pytest.mark.parametrize('watch_before_use', [True, False])
+def test_alias_property_with_force_dispatch_true(self, watch_before_use):
+    from kivy.properties import AliasProperty
+
+    class CustomAlias(EventDispatcher):
+
+        def _get_prop(self):
+            self.getter_called += 1
+
+        def _set_prop(self, value):
+            self.setter_called += 1
+
+        prop = AliasProperty(
+            _get_prop, _set_prop, force_dispatch=True,
+            watch_before_use=watch_before_use)
+
+        def __init__(self, **kwargs):
+            super(CustomAlias, self).__init__(**kwargs)
+            self.getter_called = 0
+            self.setter_called = 0
+            self.callback_called = 0
+
+    def callback(widget, value):
+        widget.callback_called += 1
+
+    # Initial checks
+    wid = CustomAlias()
+    wid.bind(prop=callback)
+    self.assertEqual(wid.getter_called, 0)
+    self.assertEqual(wid.setter_called, 0)
+    self.assertEqual(wid.callback_called, 0)
+
+    # Set property, should call setter to set the value and getter to
+    # to get the value for dispatch call
+    wid.prop = 1
+    self.assertEqual(wid.getter_called, 1)
+    self.assertEqual(wid.setter_called, 1)
+    self.assertEqual(wid.callback_called, 1)
+
+    # Set property to same value as before, setter and getter and callback
+    # are called
+    wid.prop = 1
+    self.assertEqual(wid.getter_called, 2)
+    self.assertEqual(wid.setter_called, 2)
+    self.assertEqual(wid.callback_called, 2)
+
+
+@pytest.mark.parametrize('watch_before_use', [True, False])
+def test_alias_property_cache_true_with_bind(self, watch_before_use):
+    from kivy.properties import NumericProperty, AliasProperty
+
+    class CustomAlias(EventDispatcher):
+
+        base_value = NumericProperty(1)
+
+        def _get_prop(self):
+            self.getter_called += 1
+            return self.base_value * 2
+
+        def _set_prop(self, value):
+            self.base_value = value / 2
+
+        prop = AliasProperty(_get_prop, _set_prop,
+                             bind=('base_value',),
+                             cache=True, watch_before_use=watch_before_use)
+
+        def __init__(self, **kwargs):
+            super(CustomAlias, self).__init__(**kwargs)
+            self.getter_called = 0
+
+    # Initial checks
+    wid = CustomAlias()
+    self.assertEqual(wid.getter_called, 0)
+    self.assertEqual(wid.base_value, 1)
+    self.assertEqual(wid.getter_called, 0)
+
+    # Change the base value, should trigger an update for the cache
+    wid.base_value = 4
+    self.assertEqual(wid.getter_called, int(watch_before_use))
+
+    # Now read the value again, should use the cache
+    self.assertEqual(wid.prop, 8)
+    self.assertEqual(wid.getter_called, 1)
+
+    # Change the prop itself, should trigger an update for the cache
+    wid.prop = 4
+    self.assertEqual(wid.getter_called, 2)
+    self.assertEqual(wid.base_value, 2)
+    self.assertEqual(wid.prop, 4)
+    self.assertEqual(wid.getter_called, 2)
+
+
+@pytest.mark.parametrize('watch_before_use', [True, False])
+def test_alias_property_cache_true_force_dispatch_true(self, watch_before_use):
+    from kivy.properties import AliasProperty
+
+    class CustomAlias(EventDispatcher):
+
+        def _get_prop(self):
+            self.getter_called += 1
+            return self.base_value * 2
+
+        def _set_prop(self, value):
+            self.setter_called += 1
+            self.base_value = value / 2
+            return True
+
+        prop = AliasProperty(
+            _get_prop, _set_prop, cache=True, force_dispatch=True,
+            watch_before_use=watch_before_use)
+
+        def __init__(self, **kwargs):
+            super(CustomAlias, self).__init__(**kwargs)
+            self.base_value = 1
+            self.getter_called = 0
+            self.setter_called = 0
+            self.callback_called = 0
+
+    def callback(widget, value):
+        widget.callback_called += 1
+
+    wid = CustomAlias()
+    wid.bind(prop=callback)
+
+    # Initial checks
+    self.assertEqual(wid.base_value, 1)
+    self.assertEqual(wid.getter_called, 0)
+    self.assertEqual(wid.setter_called, 0)
+    self.assertEqual(wid.callback_called, 0)
+
+    # Set alias property some value, should call setter and then getter to
+    # pass the value to callback
+    wid.prop = 16
+    self.assertEqual(wid.base_value, 8)
+    self.assertEqual(wid.getter_called, 1)
+    self.assertEqual(wid.setter_called, 1)
+    self.assertEqual(wid.callback_called, 1)
+
+    # Same as the step above, should call setter, getter and callback
+    wid.prop = 16
+    self.assertEqual(wid.base_value, 8)
+    self.assertEqual(wid.getter_called, 2)
+    self.assertEqual(wid.setter_called, 2)
+    self.assertEqual(wid.callback_called, 2)
+
+    # Get the value of property, should use cached value
+    value = wid.prop
+    self.assertEqual(value, 16)
+    self.assertEqual(wid.getter_called, 2)
+    self.assertEqual(wid.setter_called, 2)
+    self.assertEqual(wid.callback_called, 2)
+
+
+def test_dictproperty_is_none():
+    from kivy.properties import DictProperty
+
+    d1 = DictProperty(None)
+    d1.set_name(wid, 'd1')
+    d1.link_eagerly(wid)
+    assert d1.get(wid) is None
+
+    d2 = DictProperty({'a': 1, 'b': 2}, allownone=True)
+    d2.set_name(wid, 'd2')
+    d2.link_eagerly(wid)
+    d2.set(wid, None)
+    assert d2.get(wid) is None
+
+
+def test_listproperty_is_none():
+    from kivy.properties import ListProperty
+
+    l1 = ListProperty(None)
+    l1.set_name(wid, 'l1')
+    l1.link_eagerly(wid)
+    assert l1.get(wid) is None
+
+    l2 = ListProperty([1, 2, 3], allownone=True)
+    l2.set_name(wid, 'l2')
+    l2.link_eagerly(wid)
+    l2.set(wid, None)
+    assert l2.get(wid) is None
+
+
+def test_numeric_property_dp(kivy_metrics):
+    from kivy.event import EventDispatcher
+    from kivy.properties import NumericProperty
+    kivy_metrics.density = 1
+
+    class Number(EventDispatcher):
+
+        with_dp = NumericProperty(5)
+
+        no_dp = NumericProperty(10)
+
+        default_dp = NumericProperty('10dp')
+
+    number = Number()
+    counter = {'with_dp': 0, 'no_dp': 0, 'default_dp': 0}
+
+    def callback(name, *args):
+        counter[name] += 1
+
+    number.fbind('with_dp', callback, 'with_dp')
+    number.fbind('no_dp', callback, 'no_dp')
+    number.fbind('default_dp', callback, 'default_dp')
+
+    assert not counter['with_dp']
+    assert not counter['no_dp']
+    assert not counter['default_dp']
+    assert number.with_dp == 5
+    assert number.no_dp == 10
+    assert number.default_dp == 10
+
+    number.with_dp = 10
+    assert counter['with_dp'] == 1
+    assert number.with_dp == 10
+
+    kivy_metrics.density = 2
+
+    assert counter['with_dp'] == 1
+    assert not counter['no_dp']
+    assert counter['default_dp'] == 1
+    assert number.with_dp == 10
+    assert number.no_dp == 10
+    assert number.default_dp == 20
+
+    number.with_dp = '20dp'
+    number.no_dp = 20
+
+    assert counter['with_dp'] == 2
+    assert counter['no_dp'] == 1
+    assert counter['default_dp'] == 1
+    assert number.with_dp == 40
+    assert number.no_dp == 20
+    assert number.default_dp == 20
+
+    kivy_metrics.density = 1
+
+    assert counter['with_dp'] == 3
+    assert counter['no_dp'] == 1
+    assert counter['default_dp'] == 2
+    assert number.with_dp == 20
+    assert number.no_dp == 20
+    assert number.default_dp == 10
+
+
+def test_variable_list_property_dp_default(kivy_metrics):
+    from kivy.event import EventDispatcher
+    from kivy.properties import VariableListProperty
+    kivy_metrics.density = 1
+
+    class Number(EventDispatcher):
+
+        a = VariableListProperty(['10dp', (20, 'dp'), 3, 4.0])
+
+    number = Number()
+    counter = 0
+
+    def callback(name, *args):
+        nonlocal counter
+        counter += 1
+
+    number.fbind('a', callback)
+    assert list(number.a) == [10, 20, 3, 4]
+    assert not counter
+
+    kivy_metrics.density = 2
+
+    assert counter == 1
+    assert list(number.a) == [20, 40, 3, 4]
+
+    kivy_metrics.density = 1
+
+    assert counter == 2
+    assert list(number.a) == [10, 20, 3, 4]
+
+
+def test_variable_list_property_dp(kivy_metrics):
+    from kivy.event import EventDispatcher
+    from kivy.properties import VariableListProperty
+    kivy_metrics.density = 1
+
+    class Number(EventDispatcher):
+
+        a = VariableListProperty([0, 20, 3, 4])
+
+    number = Number()
+    counter = 0
+
+    def callback(name, *args):
+        nonlocal counter
+        counter += 1
+
+    number.fbind('a', callback)
+    assert list(number.a) == [0, 20, 3, 4]
+    assert not counter
+
+    number.a = ['10dp', (20, 'dp'), 3, 4.0]
+    assert list(number.a) == [10, 20, 3, 4]
+    assert counter == 1
+
+    kivy_metrics.density = 2
+
+    assert counter == 2
+    assert list(number.a) == [20, 40, 3, 4]
+
+    kivy_metrics.density = 1
+
+    assert counter == 3
+    assert list(number.a) == [10, 20, 3, 4]
+
+
+def test_property_duplicate_name():
+    from kivy.event import EventDispatcher
+    from kivy.properties import ObjectProperty
+
+    class Event(EventDispatcher):
+
+        a = ObjectProperty(5)
+
+    event = Event()
+    counter = 0
+    counter2 = 0
+
+    def callback(*args):
+        nonlocal counter
+        counter += 1
+
+    def callback2(*args):
+        nonlocal counter2
+        counter2 += 1
+
+    event.fbind('a', callback)
+
+    event.create_property('a', None)
+    event.fbind('a', callback2)
+
+    event.a = 12
+    assert not counter
+    assert counter2 == 1
+
+
+def test_property_rename_duplicate():
+    from kivy.event import EventDispatcher
+    from kivy.properties import ObjectProperty
+
+    class Event(EventDispatcher):
+
+        b = ObjectProperty(5)
+        a = b
+
+    event = Event()
+    counter = 0
+    counter2 = 0
+
+    def callback(*args):
+        nonlocal counter
+        counter += 1
+
+    def callback2(*args):
+        nonlocal counter2
+        counter2 += 1
+
+    event.fbind('a', callback)
+    event.fbind('b', callback2)
+
+    event.a = 12
+    assert counter == 1
+    assert counter2 == 1
+    assert event.a == 12
+    assert event.b == 12
+
+    event.b = 14
+    assert counter == 2
+    assert counter2 == 2
+    assert event.a == 14
+    assert event.b == 14
+
+
+def test_override_prop_inheritance():
+    from kivy.event import EventDispatcher
+    from kivy.properties import ObjectProperty, AliasProperty
+    counter = 0
+
+    class Parent(EventDispatcher):
+
+        prop = ObjectProperty()
+
+    class Child(Parent):
+
+        def inc(self, *args):
+            nonlocal counter
+            counter += 1
+            return counter
+
+        prop = AliasProperty(inc)
+
+    parent = Parent()
+    child = Child()
+
+    parent.prop = 44
+    assert parent.prop == 44
+    assert counter == 0
+    assert child.prop == 1
+    assert counter == 1
+    assert parent.prop == 44
+    assert isinstance(parent.property('prop'), ObjectProperty)
+    assert isinstance(child.property('prop'), AliasProperty)
+
+
+@pytest.mark.parametrize('by_val', [True, False])
+def test_manually_create_property(by_val):
+    from kivy.event import EventDispatcher
+    from kivy.properties import StringProperty
+
+    class Event(EventDispatcher):
+        pass
+
+    event = Event()
+    assert not hasattr(event, 'a')
+    if by_val:
+        event.create_property('a', 'hello')
+    else:
+        event.apply_property(a=StringProperty('hello'))
+    args = 0
+
+    def callback(obj, val):
+        nonlocal args
+        args = obj, val
+
+    event.fbind('a', callback)
+    assert event.a == 'hello'
+    event.a = 'bye'
+    assert event.a == 'bye'
+    assert args == (event, 'bye')
+
+    event2 = Event()
+    assert event2.a == 'hello'
+    event2.fbind('a', callback)
+    event2.a = 'goodbye'
+    assert event2.a == 'goodbye'
+    assert args == (event2, 'goodbye')
+
+
+def test_inherit_property():
+    from kivy.event import EventDispatcher
+    from kivy.properties import StringProperty
+
+    class Event(EventDispatcher):
+
+        a = StringProperty('hello')
+
+    class Event2(Event):
+
+        b = StringProperty('hello2')
+
+    event = Event2()
+    args = 0
+
+    def callback(obj, val):
+        nonlocal args
+        args = obj, val
+
+    event.fbind('a', callback)
+    event.fbind('b', callback)
+    assert event.a == 'hello'
+    assert event.b == 'hello2'
+
+    event.a = 'bye'
+    assert event.a == 'bye'
+    assert args == (event, 'bye')
+
+    event.b = 'goodbye'
+    assert event.b == 'goodbye'
+    assert args == (event, 'goodbye')
+
+
+def test_unknown_property():
+    from kivy.properties import NumericProperty
+
+    class MyWidget(EventDispatcher):
+        width = NumericProperty(0)
+
+    with pytest.raises(TypeError) as cm:
+        MyWidget(width=12, unkn="abc")
+    assert "Properties ['unkn'] passed to __init__ may not be existing " \
+           "property names. Valid properties are ['width']" \
+           == str(cm.value)
+
+
+def test_known_property_multiple_inheritance():
+
+    class Behavior:
+        def __init__(self, name):
+            print(f'Behavior: {self}, name={name}')
+            super().__init__()
+
+    class Widget2(Behavior, EventDispatcher):
+        pass
+
+    class Widget3(EventDispatcher, Behavior):
+        pass
+
+    with pytest.raises(TypeError) as cm:
+        EventDispatcher(name='Pasta')
+    assert "Properties ['name'] passed to __init__ may not be existing" \
+           in str(cm.value)
+
+    Widget2(name='Pasta')  # does not raise a ValueError
+    Widget3(name='Pasta')  # does not raise a ValueError
+
+
+def test_pass_other_typeerror():
+
+    class Behavior:
+        def __init__(self, name):
+            super().__init__()
+            raise TypeError("this is a typeerror unrelated to object")
+
+    class Widget2(Behavior, EventDispatcher):
+        pass
+
+    class Widget3(EventDispatcher, Behavior):
+        pass
+
+    for cls in [Widget2, Widget3]:
+        with pytest.raises(TypeError) as cm:
+            cls(name='Pasta')
+        assert "this is a typeerror unrelated to object" == str(cm.value)
+
+
+def test_object_init_error():  # the above 3 test rely on this
+    class TestCls(object):
+        def __init__(self, **kwargs):
+            super(TestCls, self).__init__(**kwargs)
+
+    with pytest.raises(TypeError) as cm:
+        TestCls(name='foo')
+    assert str(cm.value).startswith("object.__init__() takes")
diff --git a/kivy/tests/test_resources.py b/kivy/tests/test_resources.py
new file mode 100644
index 0000000..08e5e4e
--- /dev/null
+++ b/kivy/tests/test_resources.py
@@ -0,0 +1,79 @@
+"""
+Resource loading tests
+======================
+"""
+import pytest
+import tempfile
+import os
+from unittest.mock import patch
+from kivy.cache import Cache
+from kivy.clock import Clock
+from kivy.resources import resource_find, resource_add_path
+
+
+@pytest.fixture
+def test_file():
+    return "uix/textinput.py"
+
+
+RESOURCE_CACHE = "kv.resourcefind"
+
+
+def test_load_resource_cached(test_file):
+    Cache.remove(RESOURCE_CACHE)
+    found_file = resource_find(test_file)
+    assert found_file is not None
+    cached_filename = Cache.get(RESOURCE_CACHE, test_file)
+    assert found_file == cached_filename
+
+
+def test_load_resource_not_cached(test_file):
+    Cache.remove(RESOURCE_CACHE)
+    found_file = resource_find(test_file, use_cache=False)
+    assert found_file is not None
+    cached_filename = Cache.get(RESOURCE_CACHE, test_file)
+    assert cached_filename is None
+
+
+def test_load_resource_not_found():
+    Cache.remove(RESOURCE_CACHE)
+    missing_file_name = "missing_test_file.foo"
+
+    find_missing_file = resource_find(missing_file_name)
+    assert find_missing_file is None
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        missing_file_path = os.path.join(temp_dir, missing_file_name)
+
+        with open(missing_file_path, "w"):
+            pass  # touch file
+
+        find_missing_file_again = resource_find(missing_file_name)
+        assert find_missing_file_again is None
+
+        cached_filename = Cache.get(RESOURCE_CACHE, missing_file_name)
+        assert cached_filename is None
+
+        resource_add_path(temp_dir)
+
+        found_file = resource_find(missing_file_name)
+        assert missing_file_path == found_file
+        assert missing_file_path == Cache.get(RESOURCE_CACHE, missing_file_name)
+
+
+def test_timestamp_and_lastaccess(test_file):
+    Cache.remove(RESOURCE_CACHE)
+    start = Clock.get_time()
+
+    resource_find(test_file)
+    ts = Cache.get_timestamp(RESOURCE_CACHE, test_file)
+    last_access = Cache.get_lastaccess(RESOURCE_CACHE, test_file)
+
+    assert ts >= start, 'Last timestamp not accurate.'
+    assert last_access >= start, 'Last access time is not accurate.'
+
+
+def test_print_usage():
+    with patch('kivy.cache.print') as mock_print:
+        Cache.print_usage()
+        mock_print.assert_called()
diff --git a/kivy/tests/test_rst_replace.py b/kivy/tests/test_rst_replace.py
new file mode 100644
index 0000000..a130629
--- /dev/null
+++ b/kivy/tests/test_rst_replace.py
@@ -0,0 +1,63 @@
+# coding=utf-8
+import unittest
+from kivy.tests.common import GraphicUnitTest
+
+
+def _build_rst():
+    from kivy.uix.rst import RstDocument
+
+    class _TestRstReplace(RstDocument):
+        def __init__(self, **kwargs):
+            super(_TestRstReplace, self).__init__(**kwargs)
+            self.text = '''
+    .. |uni| unicode:: 0xe4
+    .. |nbsp| unicode:: 0xA0
+    .. |text| replace:: is
+    .. |hop| replace:: replaced
+    .. _hop: https://kivy.org
+
+    |uni| |nbsp| |text| |hop|_
+    '''
+
+    return _TestRstReplace()
+
+
+class RstSubstitutionTestCase(GraphicUnitTest):
+    # XXX Mathieu - i tried to fix the window context to prevent segfault here
+    # but nothing actually works. Works alone, but not after a window restart.
+    # On linux:
+    #    # 1  0x00007ffff12807e9 in  () at /usr/lib/libnvidia-glcore.so.418.43
+    #    # 2  0x00007ffff1288554 in  () at /usr/lib/libnvidia-glcore.so.418.43
+    #    # 3  0x00007ffff0e2e3db in  () at /usr/lib/libnvidia-glcore.so.418.43
+    #    # 4  0x00007ffff5d5ae15 in __pyx_f_4kivy_8graphics_3vbo_11VertexBatch_draw  # noqa
+    #         (__pyx_v_self=0x7fffed641390) at kivy/graphics/vbo.c:6529
+    # On OSX:
+    #  * thread #1, queue = 'com.apple.main-thread',
+    #     stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
+    #  * frame #0: 0x00007fff555d9d42 GLEngine`gleRunVertexSubmitImmediate + 1234  # noqa
+    #    frame #1: 0x00007fff554c1544 GLEngine`glDrawElements_Exec + 563
+    #    frame #2: 0x000000010429d273 vbo.cpython-36m-darwin.so
+    #    `__pyx_f_4kivy_8graphics_3vbo_11VertexBatch_draw(
+    #    __pyx_v_self=0x000000010cf344f8) at vbo.c:6575 [opt]
+    @unittest.skip("Currently segfault, but no idea why.")
+    def test_rst_replace(self):
+        rst = _build_rst()
+        self.render(rst)
+
+        # RstDocument > Scatter > GridLayout > RstParagraph
+        pg = rst.children[0].children[0].children[0]
+        rendered_text = pg.text[:]
+
+        # [anchor=] and [ref=] might change in the future
+        compare_text = (
+            u'[color=202020ff][anchor=hop]'
+            u'\xe4 \xA0 is '
+            u'[ref=None][color=ce5c00ff]replaced[/color][/ref]'
+            u'[/color]'
+        )
+        self.assertEqual(rendered_text, compare_text)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_screen.py b/kivy/tests/test_screen.py
new file mode 100644
index 0000000..46cc095
--- /dev/null
+++ b/kivy/tests/test_screen.py
@@ -0,0 +1,38 @@
+import pytest
+
+transition_cls_names = (
+    'ShaderTransition', 'SlideTransition', 'SwapTransition', 'FadeTransition',
+    'WipeTransition', 'FallOutTransition', 'RiseInTransition', 'NoTransition',
+    'CardTransition',
+)
+
+
+def test_switch_to():
+    import kivy.uix.screenmanager as sm
+    manager = sm.ScreenManager()
+    screen1 = sm.Screen(name='first')
+    screen2 = sm.Screen(name='second')
+    manager.switch_to(screen1)
+    manager.switch_to(screen2)
+    manager.switch_to(screen1)
+    manager.switch_to(screen2)
+    manager.current = 'first'
+    manager.switch_to(screen1)
+    manager.current = 'second'
+    manager.switch_to(screen2)
+
+
+@pytest.mark.parametrize('transition_cls_name', transition_cls_names)
+def test_switching_does_not_affect_a_list_of_screens(transition_cls_name):
+    import kivy.uix.screenmanager as sm
+    transition_cls = getattr(sm, transition_cls_name)
+    scrmgr = sm.ScreenManager()
+    for i in range(3):
+        scrmgr.add_widget(sm.Screen(name=str(i)))
+    names = list(scrmgr.screen_names)
+    scrmgr.transition = transition_cls()
+    scrmgr.current = '1'
+    assert names == scrmgr.screen_names
+    scrmgr.transition = transition_cls()
+    scrmgr.current = '2'
+    assert names == scrmgr.screen_names
diff --git a/kivy/tests/test_storage.py b/kivy/tests/test_storage.py
new file mode 100644
index 0000000..13271e7
--- /dev/null
+++ b/kivy/tests/test_storage.py
@@ -0,0 +1,135 @@
+'''
+Storage tests
+=============
+'''
+
+import unittest
+from os.path import abspath, dirname, join
+import errno
+import os
+
+
+class StorageTestCase(unittest.TestCase):
+    def test_dict_storage(self):
+        from kivy.storage.dictstore import DictStore
+        from tempfile import mkstemp
+        from os import unlink, close
+
+        try:
+            tmpfd, tmpfn = mkstemp('.dict')
+            close(tmpfd)
+
+            self._do_store_test_empty(DictStore(tmpfn))
+            self._do_store_test_filled(DictStore(tmpfn))
+        finally:
+            unlink(tmpfn)
+
+    def test_dict_storage_nofolder(self):
+        from kivy.storage.dictstore import DictStore
+        self._do_store_test_nofolder(DictStore)
+
+    def test_json_storage_nofolder(self):
+        from kivy.storage.jsonstore import JsonStore
+        self._do_store_test_nofolder(JsonStore)
+
+    def test_json_storage(self):
+        from kivy.storage.jsonstore import JsonStore
+        from tempfile import mkstemp
+        from os import unlink, close
+
+        try:
+            tmpfd, tmpfn = mkstemp('.json')
+            close(tmpfd)
+            self._do_store_test_empty(JsonStore(tmpfn))
+            self._do_store_test_filled(JsonStore(tmpfn))
+        finally:
+            unlink(tmpfn)
+
+        try:
+            tmpfd, tmpfn = mkstemp('.json')
+            close(tmpfd)
+            self._do_store_test_empty(JsonStore(tmpfn, indent=2))
+            self._do_store_test_filled(JsonStore(tmpfn, indent=2))
+        finally:
+            unlink(tmpfn)
+
+        try:
+            tmpfd, tmpfn = mkstemp('.json')
+            close(tmpfd)
+            self._do_store_test_empty(JsonStore(tmpfn, sort_keys=True))
+            self._do_store_test_filled(JsonStore(tmpfn, sort_keys=True))
+        finally:
+            unlink(tmpfn)
+
+    def test_redis_storage(self):
+        if os.environ.get('NONETWORK'):
+            return
+        try:
+            from kivy.storage.redisstore import RedisStore
+            from redis.exceptions import ConnectionError
+            try:
+                params = dict(db=15)
+                self._do_store_test_empty(RedisStore(params))
+                self._do_store_test_filled(RedisStore(params))
+            except ConnectionError:
+                pass
+        except ImportError:
+            pass
+
+    def _do_store_test_empty(self, store):
+        store.clear()
+        self.assertTrue(store.count() == 0)
+        self.assertFalse(store.exists('plop'))
+        self.assertRaises(KeyError, lambda: store.get('plop'))
+        self.assertTrue(store.put('plop', name='Hello', age=30))
+        self.assertTrue(store.exists('plop'))
+        self.assertTrue(store.get('plop').get('name') == 'Hello')
+        self.assertTrue(store.get('plop').get('age') == 30)
+        self.assertTrue(store.count() == 1)
+        self.assertTrue('plop' in store.keys())
+
+        # test queries
+        store.put('key1', name='Name1', attr1='Common')
+        store.put('key2', name='Name2', attr1='Common', attr2='bleh')
+        store.put('key3', name='Name3', attr1='Common', attr2='bleh')
+        self.assertTrue(store.count() == 4)
+        self.assertTrue(store.exists('key1'))
+        self.assertTrue(store.exists('key2'))
+        self.assertTrue(store.exists('key3'))
+
+        self.assertTrue(len(list(store.find(name='Name2'))) == 1)
+        self.assertTrue(list(store.find(name='Name2'))[0][0] == 'key2')
+        self.assertTrue(len(list(store.find(attr1='Common'))) == 3)
+        self.assertTrue(len(list(store.find(attr2='bleh'))) == 2)
+        self.assertTrue(
+            len(list(store.find(attr1='Common', attr2='bleh'))) == 2)
+        self.assertTrue(len(list(store.find(name='Name2', attr2='bleh'))) == 1)
+        self.assertTrue(len(list(store.find(name='Name1', attr2='bleh'))) == 0)
+
+    def _do_store_test_filled(self, store):
+        self.assertTrue(store.count() == 4)
+        self.assertRaises(KeyError, lambda: store.get('plop2'))
+        self.assertRaises(KeyError, lambda: store.delete('plop2'))
+        self.assertTrue(store.exists('plop'))
+        self.assertTrue(store.get('plop').get('name') == 'Hello')
+        self.assertTrue(store.put('plop', name='World', age=1))
+        self.assertTrue(store.get('plop').get('name') == 'World')
+        self.assertTrue(store.exists('plop'))
+        self.assertTrue(store.delete('plop'))
+        self.assertRaises(KeyError, lambda: store.delete('plop'))
+        self.assertRaises(KeyError, lambda: store.get('plop'))
+
+    def _do_store_test_nofolder(self, store_cls):
+        ext = store_cls.__name__.lower()[:4]
+        path = join(
+            dirname(abspath(__file__)),
+            '__i_dont_exist__',
+            'test.' + ext
+        )
+        with self.assertRaises(IOError) as context:
+            store = store_cls(path)
+        self.assertEqual(context.exception.errno, errno.ENOENT)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/kivy/tests/test_uix_actionbar.py b/kivy/tests/test_uix_actionbar.py
new file mode 100644
index 0000000..59ef987
--- /dev/null
+++ b/kivy/tests/test_uix_actionbar.py
@@ -0,0 +1,363 @@
+from kivy.tests.common import GraphicUnitTest, UTMotionEvent
+
+from kivy.lang import Builder
+from kivy.base import EventLoop
+from kivy.weakproxy import WeakProxy
+from time import sleep
+
+DropDown = None
+
+
+KV = '''
+# +/- copied from ActionBar example + edited for the test
+FloatLayout:
+    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:
+                id: group1
+                text: 'group 1'
+                ActionButton:
+                    id: group1button
+                    text: 'Btn3'
+                    on_release:
+                        setattr(root, 'g1button', True)
+                ActionButton:
+                    text: 'Btn4'
+            ActionGroup:
+                id: group2
+                dropdown_width: 200
+                text: 'group 2'
+                ActionButton:
+                    id: group2button
+                    text: 'Btn5'
+                    on_release:
+                        setattr(root, 'g2button', True)
+                ActionButton:
+                    text: 'Btn6'
+                ActionButton:
+                    text: 'Btn7'
+'''
+
+
+class TouchPoint(UTMotionEvent):
+    def __init__(self, raw_x, raw_y):
+        win = EventLoop.window
+        super().__init__(
+            "unittest", 1, {
+                "x": raw_x / float(win.width),
+                "y": raw_y / float(win.height),
+            }
+        )
+        # press & release
+        EventLoop.post_dispatch_input("begin", self)
+        EventLoop.post_dispatch_input("end", self)
+        EventLoop.idle()
+
+
+class ActionBarTestCase(GraphicUnitTest):
+    framecount = 0
+
+    def setUp(self):
+        global DropDown
+        from kivy.uix.dropdown import DropDown
+
+        # kill KV lang logging (too long test)
+        import kivy.lang.builder as builder
+
+        if not hasattr(self, '_trace'):
+            self._trace = builder.trace
+
+        self.builder = builder
+        builder.trace = lambda *_, **__: None
+        super(ActionBarTestCase, self).setUp()
+
+    def tearDown(self, *args, **kwargs):
+        # add the logging back
+        import kivy.lang.builder as builder
+        builder.trace = self._trace
+        super(ActionBarTestCase, self).tearDown(*args, **kwargs)
+
+    def move_frames(self, t):
+        for i in range(t):
+            EventLoop.idle()
+
+    def clean_garbage(self, *args):
+        for child in self._win.children[:]:
+            self._win.remove_widget(child)
+        self.move_frames(5)
+
+    def check_dropdown(self, present=True):
+        any_list = [
+            isinstance(child, DropDown)
+            for child in self._win.children
+        ]
+
+        # mustn't allow more than one DropDown opened!
+        self.assertLess(sum(any_list), 2)
+
+        # passed
+        if not present and not any(any_list):
+            return
+        elif present and any(any_list):
+            return
+
+        print('DropDown either missing, or isn\'t supposed to be there')
+        self.assertTrue(False)
+
+    def test_1_openclose(self, *args):
+        # click on Group 2 to open its DropDown
+        # - DropDown shows up
+        # then click away
+        # - Group 2 DropDown disappears
+        # click on Group 1 to open its DropDown
+        # - DropDown shows up
+        # then click away
+        # - Group 1 DropDown disappears
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group1 = root.ids.group1
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        items = ((group2, group1), (group1, group2))
+        for item in items:
+            active, passive = item
+            # click on active Group
+            TouchPoint(*active.center)
+
+            # active Group DropDown shows up
+            self.check_dropdown(present=True)
+            gdd = WeakProxy(self._win.children[0])
+
+            # active Group DropDown == value in WeakProxy
+            self.assertIn(gdd, self._win.children)
+            self.assertEqual(gdd, self._win.children[0])
+            self.assertTrue(active.is_open)
+            self.assertFalse(passive.is_open)
+
+            # click away
+            TouchPoint(0, 0)
+
+            # wait for closed Group DropDown to disappear
+            # go to the next frame after the DropDown disappeared
+            sleep(gdd.min_state_time)
+            self.move_frames(1)
+
+            # no DropDown is open
+            self.assertNotEqual(gdd, self._win.children[0])
+            self.assertLess(len(self._win.children), 2)
+            self.check_dropdown(present=False)
+            self.assertFalse(active.is_open)
+            self.assertFalse(passive.is_open)
+        self._win.remove_widget(root)
+
+    def test_2_switch(self, *args):
+        # click on Group 2 to open its DropDown
+        # - DropDown shows up
+        # then click on Group 1 to open its DropDown
+        # - Group 2 DropDown disappears, Group 1 DropDown shows up
+        # click away
+        # - no DropDown is opened
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group1 = root.ids.group1
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        # click on Group 2
+        TouchPoint(*group2.center)
+
+        # Group 2 DropDown shows up
+        self.check_dropdown(present=True)
+        g2dd = WeakProxy(self._win.children[0])
+
+        # Group 2 DropDown == value in WeakProxy
+        self.assertIn(g2dd, self._win.children)
+        self.assertEqual(g2dd, self._win.children[0])
+        self.assertTrue(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        # click away from ActionBar and wait for it to disappear
+        TouchPoint(0, 0)
+        sleep(g2dd.min_state_time)
+        self.move_frames(1)
+
+        # click on Group 1
+        TouchPoint(*group1.center)
+
+        # wait for closed Group 2 DropDown to disappear
+        # and for Group 1 DropDown to appear (there are 2 DDs now)
+        # go to the next frame after the DropDown disappeared
+        sleep(g2dd.min_state_time)
+        self.move_frames(1)
+
+        # Group 1 DropDown != value in WeakProxy (Group 2 DD)
+        self.assertNotEqual(g2dd, self._win.children[0])
+        self.assertFalse(group2.is_open)
+        self.assertTrue(group1.is_open)
+        self.check_dropdown(present=True)
+
+        # click away from ActionBar
+        TouchPoint(0, 0)
+
+        # wait for closed Group DropDown to disappear
+        # go to the next frame after the DropDown disappeared
+        sleep(g2dd.min_state_time)
+        self.move_frames(1)
+
+        # no DropDown present in Window
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+        self.assertNotIn(g2dd, self._win.children)
+        self._win.remove_widget(root)
+
+    def test_3_openpress(self, *args):
+        # click on Group 2 to open its DropDown
+        # - DropDown shows up
+        # then click on Group 2 DropDown button
+        # - DropDown disappears
+        # click on Group 1 to open its DropDown
+        # - DropDown shows up
+        # then click on Group 1 DropDown button
+        # - DropDown disappears
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group2button = root.ids.group2button
+        group1 = root.ids.group1
+        group1button = root.ids.group1button
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+        self.assertFalse(group1.is_open)
+
+        items = (
+            (group2, group1, group2button),
+            (group1, group2, group1button)
+        )
+        for item in items:
+            active, passive, button = item
+
+            # click on active Group
+            TouchPoint(*active.center)
+
+            # active Group DropDown shows up
+            self.check_dropdown(present=True)
+            gdd = WeakProxy(self._win.children[0])
+
+            # active Group DropDown == value in WeakProxy
+            self.assertIn(gdd, self._win.children)
+            self.assertEqual(gdd, self._win.children[0])
+            self.assertTrue(active.is_open)
+            self.assertFalse(passive.is_open)
+
+            # click on active Group DropDown Button (needed to_window)
+            TouchPoint(*button.to_window(*button.center))
+            self.assertTrue(getattr(
+                root, active.text[0::6] + 'button'
+            ))
+
+            # wait for closed Group DropDown to disappear
+            # go to the next frame after the DropDown disappeared
+            sleep(gdd.min_state_time)
+            self.move_frames(1)
+
+            # no DropDown is open
+            self.assertNotEqual(gdd, self._win.children[0])
+            self.assertLess(len(self._win.children), 2)
+            self.assertFalse(active.is_open)
+            self.assertFalse(passive.is_open)
+            self.check_dropdown(present=False)
+        self._win.remove_widget(root)
+
+    def test_4_openmulti(self, *args):
+        # click on Group to open its DropDown
+        # - DropDown shows up
+        # then click on Group DropDown button
+        # - DropDown disappears
+        # repeat
+        self._win = EventLoop.window
+        self.clean_garbage()
+        root = Builder.load_string(KV)
+        self.render(root)
+        self.assertLess(len(self._win.children), 2)
+        group2 = root.ids.group2
+        group2button = root.ids.group2button
+        group1 = root.ids.group1
+        group1button = root.ids.group1button
+        self.move_frames(5)
+
+        # no DropDown present yet
+        self.check_dropdown(present=False)
+        self.assertFalse(group2.is_open)
+
+        items = ((group2, group2button), (group1, group1button))
+        for item in items:
+            group, button = item
+
+            for _ in range(5):
+                # click on Group
+                TouchPoint(*group.center)
+
+                # Group DropDown shows up
+                self.check_dropdown(present=True)
+                gdd = WeakProxy(self._win.children[0])
+
+                # Group DropDown == value in WeakProxy
+                self.assertIn(gdd, self._win.children)
+                self.assertEqual(gdd, self._win.children[0])
+                self.assertTrue(group.is_open)
+
+                # click on Group DropDown Button
+                TouchPoint(*button.to_window(*button.center))
+
+                # wait for closed Group DropDown to disappear
+                # go to the next frame after the DropDown disappeared
+                sleep(gdd.min_state_time)
+                self.move_frames(1)
+
+                # no DropDown is open
+                self.assertNotEqual(gdd, self._win.children[0])
+                self.assertFalse(group.is_open)
+                self.check_dropdown(present=False)
+        self._win.remove_widget(root)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_uix_anchorlayout.py b/kivy/tests/test_uix_anchorlayout.py
new file mode 100644
index 0000000..c898ae1
--- /dev/null
+++ b/kivy/tests/test_uix_anchorlayout.py
@@ -0,0 +1,79 @@
+'''
+Anchor layout unit test
+=======================
+'''
+
+from kivy.tests.common import GraphicUnitTest
+
+
+class UIXAnchorLayoutTestcase(GraphicUnitTest):
+
+    def box(self, r, g, b):
+        from kivy.uix.widget import Widget
+        from kivy.graphics import Color, Rectangle
+        wid = Widget(size_hint=(None, None), size=(100, 100))
+        with wid.canvas:
+            Color(r, g, b)
+            r = Rectangle(pos=wid.pos, size=wid.size)
+
+        def linksp(instance, *largs):
+            r.pos = instance.pos
+            r.size = instance.size
+        wid.bind(pos=linksp, size=linksp)
+        return wid
+
+    def test_anchorlayout_default(self):
+        from kivy.uix.anchorlayout import AnchorLayout
+        r = self.render
+        b = self.box
+
+        layout = AnchorLayout()
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+    def test_anchorlayout_x(self):
+        from kivy.uix.anchorlayout import AnchorLayout
+        r = self.render
+        b = self.box
+
+        layout = AnchorLayout(anchor_x='left')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+        layout = AnchorLayout(anchor_x='center')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+        layout = AnchorLayout(anchor_x='right')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+    def test_anchorlayout_y(self):
+        from kivy.uix.anchorlayout import AnchorLayout
+        r = self.render
+        b = self.box
+
+        layout = AnchorLayout(anchor_y='bottom')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+        layout = AnchorLayout(anchor_y='center')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+        layout = AnchorLayout(anchor_y='top')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+    def test_anchor_layout_xy(self):
+        from kivy.uix.anchorlayout import AnchorLayout
+        r = self.render
+        b = self.box
+
+        layout = AnchorLayout(anchor_y='bottom', anchor_x='left')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
+
+        layout = AnchorLayout(anchor_y='top', anchor_x='right')
+        layout.add_widget(b(1, 0, 0))
+        r(layout)
diff --git a/kivy/tests/test_uix_asyncimage.py b/kivy/tests/test_uix_asyncimage.py
new file mode 100644
index 0000000..330c90b
--- /dev/null
+++ b/kivy/tests/test_uix_asyncimage.py
@@ -0,0 +1,133 @@
+from os import remove
+from os.path import join
+from shutil import copyfile, rmtree
+from tempfile import mkdtemp
+from threading import Event
+from zipfile import ZipFile
+try:
+    from urllib import urlretrieve
+except ImportError:
+    from urllib.request import urlretrieve
+
+from kivy.tests.common import GraphicUnitTest, ensure_web_server
+
+
+class AsyncImageTestCase(GraphicUnitTest):
+
+    @classmethod
+    def setUpClass(cls):
+        from kivy import kivy_examples_dir
+        ensure_web_server(kivy_examples_dir)
+
+    def setUp(self):
+        from kivy.config import Config
+        self.maxfps = Config.getint('graphics', 'maxfps')
+        assert(self.maxfps > 0)
+        super(AsyncImageTestCase, self).setUp()
+
+    def zip_frames(self, path):
+        with ZipFile(path) as zipf:
+            return len(zipf.namelist())
+
+    def wait_for_event_or_timeout(self, event):
+        timeout = 30 * self.maxfps
+        while timeout and not event.is_set():
+            self.advance_frames(1)
+            timeout -= 1
+
+    def load_zipimage(self, source, frames):
+        # load ZIP with images named: 000.png, 001.png, ...
+        from kivy.uix.image import AsyncImage
+        event = Event()
+        image = AsyncImage(anim_delay=0.0333333333333333)
+        # bind to 'on_load' because there are various
+        # steps where the image is (re)loaded, but
+        # the event is triggered only at the end
+        image.bind(on_load=lambda *args, **kwargs: event.set())
+        image.source = source
+        self.wait_for_event_or_timeout(event)
+        self.render(image)
+        proxyimg = image._coreimage
+        self.assertTrue(proxyimg.anim_available)
+        self.assertEqual(len(proxyimg.image.textures), frames)
+        return image
+
+    def test_remote_zipsequence(self):
+        # cube ZIP has 63 PNGs used for animation
+        zip_cube = (
+            'http://localhost:8000/widgets/'
+            'sequenced_images/data/images/cube.zip'
+        )
+        # ref Loader._load_urllib
+        tempf, headers = urlretrieve(zip_cube)
+        zip_pngs = self.zip_frames(tempf)
+        remove(tempf)
+        image = self.load_zipimage(zip_cube, zip_pngs)
+        # pure delay * fps isn't enough and
+        # just +1 isn't either (index collisions)
+        self.assertTrue(self.check_sequence_frames(
+            image._coreimage,
+            int(image._coreimage.anim_delay * self.maxfps + 3)
+        ))
+
+    def test_local_zipsequence(self):
+        # cube ZIP has 63 PNGs used for animation
+        from kivy import kivy_examples_dir
+        zip_cube = join(
+            kivy_examples_dir, 'widgets', 'sequenced_images',
+            'data', 'images', 'cube.zip'
+        )
+        zip_pngs = self.zip_frames(zip_cube)
+        image = self.load_zipimage(zip_cube, zip_pngs)
+        # pure delay * fps isn't enough and
+        # just +1 isn't either (index collisions)
+        self.assertTrue(self.check_sequence_frames(
+            image._coreimage,
+            int(image._coreimage.anim_delay * self.maxfps + 3)
+        ))
+
+    def check_sequence_frames(self, img, frames, slides=5):
+        # check whether it really changes the images
+        # in the anim_delay interval
+        old = None
+        while slides:
+            # different frames, sequence is changing
+            self.assertNotEqual(img.anim_index, old)
+            old = img.anim_index
+            self.advance_frames(frames)
+            slides -= 1
+        return True
+
+    def test_reload_asyncimage(self):
+        from kivy.resources import resource_find
+        from kivy.uix.image import AsyncImage
+
+        temp_dir = mkdtemp()
+        event = Event()
+        image = AsyncImage()
+        image.bind(on_load=lambda *args, **kwargs: event.set())
+
+        fn = resource_find('data/logo/kivy-icon-16.png')
+        source = join(temp_dir, 'source.png')
+        copyfile(fn, source)
+        event.clear()
+        image.source = source
+        self.wait_for_event_or_timeout(event)
+        self.render(image, framecount=2)
+        self.assertEqual(image.texture_size, [16, 16])
+        remove(source)
+
+        fn = resource_find('data/logo/kivy-icon-32.png')
+        copyfile(fn, source)
+        event.clear()
+        image.reload()
+        self.wait_for_event_or_timeout(event)
+        self.render(image, framecount=2)
+        self.assertEqual(image.texture_size, [32, 32])
+        remove(source)
+        rmtree(temp_dir)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_uix_boxlayout.py b/kivy/tests/test_uix_boxlayout.py
new file mode 100644
index 0000000..8d450c3
--- /dev/null
+++ b/kivy/tests/test_uix_boxlayout.py
@@ -0,0 +1,94 @@
+'''
+Box layout unit test
+====================
+
+Order matter.
+On the screen, most of example must have the red->blue->green order.
+'''
+
+from kivy.tests.common import GraphicUnitTest
+
+
+class UIXBoxLayoutTestcase(GraphicUnitTest):
+
+    def box(self, r, g, b):
+        from kivy.uix.widget import Widget
+        from kivy.graphics import Color, Rectangle
+        wid = Widget()
+        with wid.canvas:
+            Color(r, g, b)
+            r = Rectangle(pos=wid.pos, size=wid.size)
+
+        def linksp(instance, *largs):
+            r.pos = instance.pos
+            r.size = instance.size
+        wid.bind(pos=linksp, size=linksp)
+        return wid
+
+    def test_boxlayout_orientation(self):
+        from kivy.uix.boxlayout import BoxLayout
+        r = self.render
+        b = self.box
+
+        layout = BoxLayout()
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
+
+        layout = BoxLayout(orientation='vertical')
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
+
+    def test_boxlayout_spacing(self):
+        from kivy.uix.boxlayout import BoxLayout
+        r = self.render
+        b = self.box
+
+        layout = BoxLayout(spacing=20)
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
+
+        layout = BoxLayout(spacing=20, orientation='vertical')
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
+
+    def test_boxlayout_padding(self):
+        from kivy.uix.boxlayout import BoxLayout
+        r = self.render
+        b = self.box
+
+        layout = BoxLayout(padding=20)
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
+
+        layout = BoxLayout(padding=20, orientation='vertical')
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
+
+    def test_boxlayout_padding_spacing(self):
+        from kivy.uix.boxlayout import BoxLayout
+        r = self.render
+        b = self.box
+
+        layout = BoxLayout(spacing=20, padding=20)
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
+
+        layout = BoxLayout(spacing=20, padding=20, orientation='vertical')
+        layout.add_widget(b(1, 0, 0))
+        layout.add_widget(b(0, 1, 0))
+        layout.add_widget(b(0, 0, 1))
+        r(layout)
diff --git a/kivy/tests/test_uix_bubble.py b/kivy/tests/test_uix_bubble.py
new file mode 100644
index 0000000..9315ee7
--- /dev/null
+++ b/kivy/tests/test_uix_bubble.py
@@ -0,0 +1,22 @@
+import pytest
+
+
+@pytest.mark.parametrize('prop_name', (
+    '_fills_row_first',
+    '_fills_from_left_to_right',
+    '_fills_from_top_to_bottom',
+))
+def test_a_certain_properties_from_the_super_class_are_overwritten(prop_name):
+    from kivy.uix.bubble import Bubble
+    from kivy.uix.gridlayout import GridLayout
+    assert issubclass(Bubble, GridLayout)
+    assert getattr(Bubble, prop_name) is not getattr(GridLayout, prop_name)
+
+
+@pytest.mark.parametrize('orientation', ('vertical', 'horizontal'))
+def test_always_lr_tb(orientation):
+    from kivy.uix.bubble import Bubble
+    b = Bubble(orientation=orientation)
+    assert b._fills_row_first
+    assert b._fills_from_left_to_right
+    assert b._fills_from_top_to_bottom
diff --git a/kivy/tests/test_uix_carousel.py b/kivy/tests/test_uix_carousel.py
new file mode 100644
index 0000000..f61aa86
--- /dev/null
+++ b/kivy/tests/test_uix_carousel.py
@@ -0,0 +1,93 @@
+import pytest
+
+
+@pytest.fixture(
+    scope='session', params=(True, False), ids=lambda v: 'loop=' + str(v))
+def loop(request):
+    return request.param
+
+
+def test_remove_widget(loop):
+    from kivy.uix.carousel import Carousel
+    from kivy.uix.widget import Widget
+
+    c = Carousel(loop=loop)
+    assert c.index is None
+    assert c.current_slide is None
+    assert len(c.children) == 0
+    assert len(c.slides) == 0
+
+    N_SLIDES = 4
+    for i in range(N_SLIDES):
+        c.add_widget(Widget())
+    assert c.index == 0
+    assert c.current_slide == c.slides[0]
+    assert len(c.children) == 3 if loop else 2
+    assert len(c.slides) == N_SLIDES
+
+    # test issue #6370
+    c.index = len(c.slides) - 1
+    c.remove_widget(c.slides[0])
+
+    # remove a slide(smaller index than the current_slide's).
+    c.index = 1
+    old_current_slide = c.current_slide
+    c.remove_widget(c.slides[c.index - 1])
+    assert c.index == 0
+    assert c.current_slide is old_current_slide
+    assert len(c.children) == 2
+    assert len(c.slides) == 2
+
+    # remove a slide(bigger index than the current_slide's).
+    old_current_slide = c.current_slide
+    c.remove_widget(c.slides[c.index + 1])
+    assert c.index == 0
+    assert c.current_slide is old_current_slide
+    assert len(c.children) == 1
+    assert len(c.slides) == 1
+
+    # remove the current_slide(the last one left).
+    c.remove_widget(c.current_slide)
+    assert c.index is None
+    assert c.current_slide is None
+    assert len(c.children) == 0
+    assert len(c.slides) == 0
+
+
+@pytest.mark.parametrize(
+    ('n_slides', 'index', 'loop',
+    'index_of_previous_slide', 'index_of_next_slide'),
+    (
+        (1, 0, False, None, None),
+        (1, 0, True, None, None),
+        (2, 0, False, None, 1),
+        (2, 0, True, 1, 1),
+        (2, 1, False, 0, None),
+        (2, 1, True, 0, 0),
+        (3, 0, False, None, 1),
+        (3, 0, True, 2, 1),
+        (3, 1, False, 0, 2),
+        (3, 1, True, 0, 2),
+        (3, 2, False, 1, None),
+        (3, 2, True, 1, 0),
+    )
+)
+def test_previous_and_next(
+    n_slides, index, loop, index_of_previous_slide, index_of_next_slide
+):
+    from kivy.uix.carousel import Carousel
+    from kivy.uix.widget import Widget
+    c = Carousel(loop=loop)
+    for i in range(n_slides):
+        c.add_widget(Widget())
+    c.index = index
+    p_slide = c.previous_slide
+    assert (p_slide and c.slides.index(p_slide)) == index_of_previous_slide
+    n_slide = c.next_slide
+    assert (n_slide and c.slides.index(n_slide)) == index_of_next_slide
+
+
+if __name__ == "__main__":
+    pytest.main(args=[
+        __file__,
+    ])
diff --git a/kivy/tests/test_uix_dropdown.py b/kivy/tests/test_uix_dropdown.py
new file mode 100644
index 0000000..60634ac
--- /dev/null
+++ b/kivy/tests/test_uix_dropdown.py
@@ -0,0 +1,91 @@
+from kivy.tests import async_run, UnitKivyApp
+
+
+def dropdown_app():
+    from kivy.app import App
+    from kivy.uix.button import Button
+    from kivy.uix.dropdown import DropDown
+    from kivy.uix.label import Label
+
+    class RootButton(Button):
+
+        dropdown = None
+
+        def on_touch_down(self, touch):
+            assert self.dropdown.attach_to is None
+            return super(RootButton, self).on_touch_down(touch)
+
+        def on_touch_move(self, touch):
+            assert self.dropdown.attach_to is None
+            return super(RootButton, self).on_touch_move(touch)
+
+        def on_touch_up(self, touch):
+            assert self.dropdown.attach_to is None
+            return super(RootButton, self).on_touch_up(touch)
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            root = RootButton(text='Root')
+            self.attach_widget = Label(text='Attached widget')
+            root.add_widget(self.attach_widget)
+
+            root.dropdown = self.dropdown = DropDown(
+                auto_dismiss=True, min_state_time=0)
+            self.inner_widget = w = Label(
+                size_hint=(None, None), text='Dropdown')
+            root.dropdown.add_widget(w)
+            return root
+
+    return TestApp()
+
+
+@async_run(app_cls_func=dropdown_app)
+async def test_dropdown_app(kivy_app):
+    await kivy_app.wait_clock_frames(2)
+    dropdown = kivy_app.dropdown
+    button = kivy_app.root
+    assert dropdown.attach_to is None
+
+    kivy_app.attach_widget.size = button.width * 3 / 5, 2
+    kivy_app.attach_widget.top = button.height
+    kivy_app.inner_widget.size = button.width * 3 / 5, button.height
+
+    # just press button
+    async for _ in kivy_app.do_touch_down_up(widget=button):
+        pass
+    async for _ in kivy_app.do_touch_drag(widget=button, dx=button.width / 4):
+        pass
+
+    # open dropdown
+    dropdown.open(kivy_app.attach_widget)
+    dropdown.pos = 0, 0
+    await kivy_app.wait_clock_frames(2)
+    assert dropdown.attach_to is not None
+
+    # press within dropdown area - should stay open
+    async for _ in kivy_app.do_touch_down_up(widget=button):
+        pass
+    assert dropdown.attach_to is not None
+    # start in dropdown but release outside - should stay open
+    async for _ in kivy_app.do_touch_drag(widget=button, dx=button.width / 4):
+        pass
+    assert dropdown.attach_to is not None
+
+    # start outside but release in dropdown - should close
+    async for _ in kivy_app.do_touch_drag(
+            pos=(button.center_x + button.width / 4, button.center_y),
+            target_widget=button):
+        pass
+    assert dropdown.attach_to is None
+
+    # open dropdown again
+    dropdown.open(kivy_app.attach_widget)
+    dropdown.pos = 0, 0
+    await kivy_app.wait_clock_frames(2)
+    assert dropdown.attach_to is not None
+
+    # press outside dropdown area to close it - should close
+    async for _ in kivy_app.do_touch_down_up(
+            pos=(button.center_x + button.width / 4, button.center_y)):
+        pass
+    assert dropdown.attach_to is None
diff --git a/kivy/tests/test_uix_gridlayout.py b/kivy/tests/test_uix_gridlayout.py
new file mode 100644
index 0000000..884cce7
--- /dev/null
+++ b/kivy/tests/test_uix_gridlayout.py
@@ -0,0 +1,244 @@
+'''
+uix.gridlayout tests
+========================
+'''
+
+import unittest
+import pytest
+from kivy.tests.common import GraphicUnitTest
+
+from kivy.uix.gridlayout import GridLayout
+
+
+class GridLayoutTest(unittest.TestCase):
+
+    def test_gridlayout_get_max_widgets_cols_rows_None(self):
+        gl = GridLayout()
+        expected = None
+        value = gl.get_max_widgets()
+        self.assertEqual(expected, value)
+
+    def test_gridlayout_get_max_widgets_rows_None(self):
+        gl = GridLayout()
+        gl.cols = 1
+        expected = None
+        value = gl.get_max_widgets()
+        self.assertEqual(expected, value)
+
+    def test_gridlayout_get_max_widgets_cols_None(self):
+        gl = GridLayout()
+        gl.rows = 1
+        expected = None
+        value = gl.get_max_widgets()
+        self.assertEqual(expected, value)
+
+    def test_gridlayout_get_max_widgets_with_rows_cols(self):
+        gl = GridLayout()
+        gl.rows = 5
+        gl.cols = 3
+        expected = 15
+        value = gl.get_max_widgets()
+        self.assertEqual(expected, value)
+
+
+class UixGridLayoutTest(GraphicUnitTest):
+
+    def test_rows_cols_sizes(self):
+        # ref github issue #5278 _init_rows_cols_sizes fix
+        # this combination could trigger an error
+        gl = GridLayout()
+        gl.cols = 1
+        gl.cols_minimum = {i: 10 for i in range(10)}
+        gl.add_widget(GridLayout())
+        self.render(gl)
+
+
+@pytest.mark.parametrize(
+    "n_cols, n_rows, orientation, expectation", [
+        (2, 3, 'lr-tb', [(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2)]),
+        (2, 3, 'lr-bt', [(0, 2), (1, 2), (0, 1), (1, 1), (0, 0), (1, 0)]),
+        (2, 3, 'rl-tb', [(1, 0), (0, 0), (1, 1), (0, 1), (1, 2), (0, 2)]),
+        (2, 3, 'rl-bt', [(1, 2), (0, 2), (1, 1), (0, 1), (1, 0), (0, 0)]),
+        (2, 3, 'tb-lr', [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]),
+        (2, 3, 'tb-rl', [(1, 0), (1, 1), (1, 2), (0, 0), (0, 1), (0, 2)]),
+        (2, 3, 'bt-lr', [(0, 2), (0, 1), (0, 0), (1, 2), (1, 1), (1, 0)]),
+        (2, 3, 'bt-rl', [(1, 2), (1, 1), (1, 0), (0, 2), (0, 1), (0, 0)]),
+    ]
+)
+def test_create_idx_iter(
+        n_cols, n_rows, orientation, expectation):
+    from kivy.uix.gridlayout import GridLayout
+    gl = GridLayout(orientation=orientation)
+    index_iter = gl._create_idx_iter(n_cols, n_rows)
+    assert expectation == list(index_iter)
+
+
+@pytest.mark.parametrize("orientation", [
+    'lr-tb', 'lr-bt', 'rl-tb', 'rl-bt',
+    'tb-lr', 'tb-rl', 'bt-lr', 'bt-rl',
+])
+def test_create_idx_iter2(orientation):
+    from kivy.uix.gridlayout import GridLayout
+    gl = GridLayout(orientation=orientation)
+    index_iter = gl._create_idx_iter(1, 1)
+    assert [(0, 0)] == list(index_iter)
+
+
+class TestLayout_fixed_sized_children:
+    def compute_layout(self, *, n_cols, n_rows, ori, n_children):
+        from kivy.uix.widget import Widget
+        from kivy.uix.gridlayout import GridLayout
+        gl = GridLayout(cols=n_cols, rows=n_rows, orientation=ori, pos=(0, 0))
+        gl.bind(minimum_size=gl.setter("size"))
+        for __ in range(n_children):
+            # set 'pos' to some random value to make this test more reliable
+            gl.add_widget(Widget(
+                size_hint=(None, None), size=(100, 100), pos=(8, 8)))
+        gl.do_layout()
+        return [tuple(c.pos) for c in reversed(gl.children)]
+
+    # |---|
+    # | 0 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 1), (1, 1)])
+    def test_1x1(self, n_cols, n_rows):
+        from kivy.uix.gridlayout import GridLayout
+        for ori in GridLayout.orientation.options:
+            assert [(0, 0), ] == self.compute_layout(
+                n_children=1, ori=ori, n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|---|
+    # | 0 | 1 | 2 |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 1), (3, 1)])
+    @pytest.mark.parametrize("ori", "lr-tb lr-bt tb-lr bt-lr".split())
+    def test_3x1_lr(self, ori, n_cols, n_rows):
+        assert [(0, 0), (100, 0), (200, 0)] == self.compute_layout(
+            n_children=3, ori=ori, n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|---|
+    # | 2 | 1 | 0 |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 1), (3, 1)])
+    @pytest.mark.parametrize("ori", "rl-tb rl-bt tb-rl bt-rl".split())
+    def test_3x1_rl(self, ori, n_cols, n_rows):
+        assert [(200, 0), (100, 0), (0, 0)] == self.compute_layout(
+            n_children=3, ori=ori, n_cols=n_cols, n_rows=n_rows)
+
+    # |---|
+    # | 0 |
+    # |---|
+    # | 1 |
+    # |---|
+    # | 2 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 3), (1, 3)])
+    @pytest.mark.parametrize("ori", "tb-lr tb-rl lr-tb rl-tb".split())
+    def test_1x3_tb(self, ori, n_cols, n_rows):
+        assert [(0, 200), (0, 100), (0, 0)] == self.compute_layout(
+            n_children=3, ori=ori, n_cols=n_cols, n_rows=n_rows)
+
+    # |---|
+    # | 2 |
+    # |---|
+    # | 1 |
+    # |---|
+    # | 0 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 3), (1, 3)])
+    @pytest.mark.parametrize("ori", "bt-lr bt-rl lr-bt rl-bt".split())
+    def test_1x3_bt(self, ori, n_cols, n_rows):
+        assert [(0, 0), (0, 100), (0, 200)] == self.compute_layout(
+            n_children=3, ori=ori, n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 0 | 1 |
+    # |---|---|
+    # | 2 | 3 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_lr_tb(self, n_cols, n_rows):
+        assert [(0, 100), (100, 100), (0, 0), (100, 0)] == \
+            self.compute_layout(
+                n_children=4, ori='lr-tb', n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 2 | 3 |
+    # |---|---|
+    # | 0 | 1 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_lr_bt(self, n_cols, n_rows):
+        assert [(0, 0), (100, 0), (0, 100), (100, 100)] == \
+            self.compute_layout(
+                n_children=4, ori='lr-bt', n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 1 | 0 |
+    # |---|---|
+    # | 3 | 2 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_rl_tb(self, n_cols, n_rows):
+        assert [(100, 100), (0, 100), (100, 0), (0, 0)] == \
+            self.compute_layout(
+                n_children=4, ori='rl-tb', n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 3 | 2 |
+    # |---|---|
+    # | 1 | 0 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_rl_bt(self, n_cols, n_rows):
+        assert [(100, 0), (0, 0), (100, 100), (0, 100)] == \
+            self.compute_layout(
+                n_children=4, ori='rl-bt', n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 0 | 2 |
+    # |---|---|
+    # | 1 | 3 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_tb_lr(self, n_cols, n_rows):
+        assert [(0, 100), (0, 0), (100, 100), (100, 0)] == \
+            self.compute_layout(
+                n_children=4, ori='tb-lr', n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 2 | 0 |
+    # |---|---|
+    # | 3 | 1 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_tb_rl(self, n_cols, n_rows):
+        assert [(100, 100), (100, 0), (0, 100), (0, 0)] == \
+            self.compute_layout(
+                n_children=4, ori='tb-rl', n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 1 | 3 |
+    # |---|---|
+    # | 0 | 2 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_bt_lr(self, n_cols, n_rows):
+        assert [(0, 0), (0, 100), (100, 0), (100, 100)] == \
+            self.compute_layout(
+                n_children=4, ori='bt-lr', n_cols=n_cols, n_rows=n_rows)
+
+    # |---|---|
+    # | 3 | 1 |
+    # |---|---|
+    # | 2 | 0 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_bt_rl(self, n_cols, n_rows):
+        assert [(100, 0), (100, 100), (0, 0), (0, 100)] == \
+            self.compute_layout(
+                n_children=4, ori='bt-rl', n_cols=n_cols, n_rows=n_rows)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/kivy/tests/test_uix_layout.py b/kivy/tests/test_uix_layout.py
new file mode 100644
index 0000000..c288f2d
--- /dev/null
+++ b/kivy/tests/test_uix_layout.py
@@ -0,0 +1,16 @@
+'''
+uix.layout tests
+================
+Layout class is Abstract Base Class.
+'''
+
+import unittest
+
+from kivy.uix.layout import Layout
+
+
+class UixLayoutTest(unittest.TestCase):
+
+    def test_instantiation(self):
+        with self.assertRaises(Exception):
+            layout = Layout()
diff --git a/kivy/tests/test_uix_modal.py b/kivy/tests/test_uix_modal.py
new file mode 100644
index 0000000..248fc46
--- /dev/null
+++ b/kivy/tests/test_uix_modal.py
@@ -0,0 +1,101 @@
+""" modal view unit tests. """
+from kivy.tests import async_run, UnitKivyApp
+from math import isclose
+
+
+def modal_app():
+    """ test app factory function. """
+    from kivy.app import App
+    from kivy.uix.button import Button
+    from kivy.uix.modalview import ModalView
+
+    # noinspection PyProtectedMember
+    class ModalButton(Button):
+        """ button used as root widget to test touch. """
+        modal = None
+
+        def on_touch_down(self, touch):
+            """ touch down event handler. """
+            assert self.modal._window is None
+            assert not self.modal._is_open
+            return super(ModalButton, self).on_touch_down(touch)
+
+        def on_touch_move(self, touch):
+            """ touch move event handler. """
+            assert self.modal._window is None
+            assert not self.modal._is_open
+            return super(ModalButton, self).on_touch_move(touch)
+
+        def on_touch_up(self, touch):
+            """ touch up event handler. """
+            assert self.modal._window is None
+            assert not self.modal._is_open
+            return super(ModalButton, self).on_touch_up(touch)
+
+    class TestApp(UnitKivyApp, App):
+        """ test app class. """
+        def build(self):
+            """ build root layout. """
+            root = ModalButton()
+            root.modal = ModalView(size_hint=(.2, .5))
+            return root
+
+    return TestApp()
+
+
+@async_run(app_cls_func=modal_app)
+async def test_modal_app(kivy_app):
+    await kivy_app.wait_clock_frames(2)
+    button = kivy_app.root
+    modal = button.modal
+    modal._anim_duration = 0
+    assert modal._window is None
+    assert not modal._is_open
+
+    # just press button
+    async for _ in kivy_app.do_touch_down_up(widget=button):
+        assert modal._window is None
+        assert not modal._is_open
+    async for _ in kivy_app.do_touch_drag(widget=button, dx=button.width / 4):
+        assert modal._window is None
+        assert not modal._is_open
+
+    # open modal
+    modal.open()
+    await kivy_app.wait_clock_frames(2)
+    assert modal._window is not None
+    assert modal._is_open
+    assert isclose(modal.center_x, button.center_x, abs_tol=.1)
+    assert isclose(modal.center_y, button.center_y, abs_tol=.1)
+
+    # press within modal area - should stay open
+    async for _ in kivy_app.do_touch_down_up(widget=button):
+        pass
+    assert modal._window is not None
+    assert modal._is_open
+    # start in modal but release outside - should stay open
+    async for _ in kivy_app.do_touch_drag(widget=button, dx=button.width / 4):
+        pass
+    assert modal._window is not None
+    assert modal._is_open
+
+    # start outside but release in modal - should close
+    async for _ in kivy_app.do_touch_drag(
+            pos=(button.center_x + button.width / 4, button.center_y),
+            target_widget=button):
+        pass
+    assert modal._window is None
+    assert not modal._is_open
+
+    # open modal again
+    modal.open()
+    await kivy_app.wait_clock_frames(2)
+    assert modal._window is not None
+    assert modal._is_open
+
+    # press outside modal area - should close
+    async for _ in kivy_app.do_touch_down_up(
+            pos=(button.center_x + button.width / 4, button.center_y)):
+        pass
+    assert modal._window is None
+    assert not modal._is_open
diff --git a/kivy/tests/test_uix_recyclegridlayout.py b/kivy/tests/test_uix_recyclegridlayout.py
new file mode 100644
index 0000000..9de6f28
--- /dev/null
+++ b/kivy/tests/test_uix_recyclegridlayout.py
@@ -0,0 +1,383 @@
+import pytest
+
+
+class TestLayout_all_the_data_is_visible:
+    def compute_layout(self, *, n_cols, n_rows, orientation, n_data, clock):
+        '''Returns {view-index: pos, view-index: pos, ...}'''
+        from textwrap import dedent
+        from kivy.lang import Builder
+
+        # Use Kv because RecycleView cannot be constructed from python
+        rv = Builder.load_string(dedent(f'''
+            RecycleView:
+                viewclass: 'Widget'
+                size: 300, 300
+                data: ({{}} for __ in range({n_data}))
+                RecycleGridLayout:
+                    id: layout
+                    cols: {n_cols}
+                    rows: {n_rows}
+                    orientation: '{orientation}'
+                    default_size_hint: None, None
+                    default_size: 100, 100
+                    size_hint: None, None
+                    size: self.minimum_size
+            '''))
+        clock.tick()
+        layout = rv.ids.layout
+        return {
+            layout.get_view_index_at(c.center): tuple(c.pos)
+            for c in layout.children
+        }
+
+    # |---|
+    # | 0 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 1), (1, 1)])
+    def test_1x1(self, kivy_clock, n_cols, n_rows):
+        from kivy.uix.recyclegridlayout import RecycleGridLayout
+        for orientation in RecycleGridLayout.orientation.options:
+            assert {0: (0, 0), } == self.compute_layout(
+                n_data=1, orientation=orientation, n_cols=n_cols,
+                n_rows=n_rows, clock=kivy_clock)
+
+    # |---|---|---|
+    # | 0 | 1 | 2 |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 1), (3, 1)])
+    @pytest.mark.parametrize("orientation", "lr-tb lr-bt tb-lr bt-lr".split())
+    def test_3x1_lr(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {0: (0, 0), 1: (100, 0), 2: (200, 0)} == self.compute_layout(
+            n_data=3, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|---|---|
+    # | 2 | 1 | 0 |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 1), (3, 1)])
+    @pytest.mark.parametrize("orientation", "rl-tb rl-bt tb-rl bt-rl".split())
+    def test_3x1_rl(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {0: (200, 0), 1: (100, 0), 2: (0, 0)} == self.compute_layout(
+            n_data=3, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|
+    # | 0 |
+    # |---|
+    # | 1 |
+    # |---|
+    # | 2 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 3), (1, 3)])
+    @pytest.mark.parametrize("orientation", "tb-lr tb-rl lr-tb rl-tb".split())
+    def test_1x3_tb(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {0: (0, 200), 1: (0, 100), 2: (0, 0)} == self.compute_layout(
+            n_data=3, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|
+    # | 2 |
+    # |---|
+    # | 1 |
+    # |---|
+    # | 0 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 3), (1, 3)])
+    @pytest.mark.parametrize("orientation", "bt-lr bt-rl lr-bt rl-bt".split())
+    def test_1x3_bt(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {0: (0, 0), 1: (0, 100), 2: (0, 200)} == self.compute_layout(
+            n_data=3, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|---|
+    # | 0 | 1 |
+    # |---|---|
+    # | 2 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_lr_tb(self, kivy_clock, n_cols, n_rows):
+        assert {0: (0, 100), 1: (100, 100), 2: (0, 0)} == self.compute_layout(
+            n_data=3, orientation='lr-tb', n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|
+    # | 2 |
+    # |---|---|
+    # | 0 | 1 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_lr_bt(self, kivy_clock, n_cols, n_rows):
+        assert {0: (0, 0), 1: (100, 0), 2: (0, 100)} == self.compute_layout(
+            n_data=3, orientation='lr-bt', n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|---|
+    # | 1 | 0 |
+    # |---|---|
+    #     | 2 |
+    #     |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_rl_tb(self, kivy_clock, n_cols, n_rows):
+        assert {0: (100, 100), 1: (0, 100), 2: (100, 0)} == \
+            self.compute_layout(
+                n_data=3, orientation='rl-tb', n_cols=n_cols, n_rows=n_rows,
+                clock=kivy_clock)
+
+    #     |---|
+    #     | 2 |
+    # |---|---|
+    # | 1 | 0 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_rl_bt(self, kivy_clock, n_cols, n_rows):
+        assert {0: (100, 0), 1: (0, 0), 2: (100, 100)} == self.compute_layout(
+            n_data=3, orientation='rl-bt', n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|---|
+    # | 0 | 2 |
+    # |---|---|
+    # | 1 |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_tb_lr(self, kivy_clock, n_cols, n_rows):
+        assert {0: (0, 100), 1: (0, 0), 2: (100, 100)} == self.compute_layout(
+            n_data=3, orientation='tb-lr', n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    # |---|---|
+    # | 2 | 0 |
+    # |---|---|
+    #     | 1 |
+    #     |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_tb_rl(self, kivy_clock, n_cols, n_rows):
+        assert {0: (100, 100), 1: (100, 0), 2: (0, 100)} == \
+            self.compute_layout(
+                n_data=3, orientation='tb-rl', n_cols=n_cols, n_rows=n_rows,
+                clock=kivy_clock)
+
+    # |---|
+    # | 1 |
+    # |---|---|
+    # | 0 | 2 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_bt_lr(self, kivy_clock, n_cols, n_rows):
+        assert {0: (0, 0), 1: (0, 100), 2: (100, 0)} == self.compute_layout(
+            n_data=3, orientation='bt-lr', n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+    #     |---|
+    #     | 1 |
+    # |---|---|
+    # | 2 | 0 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(2, None), (None, 2), (2, 2)])
+    def test_2x2_bt_rl(self, kivy_clock, n_cols, n_rows):
+        assert {0: (100, 0), 1: (100, 100), 2: (0, 0)} == self.compute_layout(
+            n_data=3, orientation='bt-rl', n_cols=n_cols, n_rows=n_rows,
+            clock=kivy_clock)
+
+
+class TestLayout_only_a_part_of_the_data_is_visible:
+    def compute_layout(self, *, n_cols, n_rows, orientation, n_data,
+                       scroll_to, clock):
+        '''Returns {view-index: pos, view-index: pos, ...}'''
+        from textwrap import dedent
+        from kivy.lang import Builder
+
+        # Use Kv because RecycleView cannot be constructed from python
+        rv = Builder.load_string(dedent(f'''
+            RecycleView:
+                viewclass: 'Widget'
+                size: 100, 100
+                data: ({{}} for __ in range({n_data}))
+                RecycleGridLayout:
+                    id: layout
+                    cols: {n_cols}
+                    rows: {n_rows}
+                    orientation: '{orientation}'
+                    default_size_hint: None, None
+                    default_size: 100, 100
+                    size_hint: None, None
+                    size: self.minimum_size
+            '''))
+        clock.tick()
+        layout = rv.ids.layout
+        x, y = scroll_to
+        scrollable_width = layout.width - rv.width
+        if scrollable_width:  # avoids ZeroDivisionError
+            rv.scroll_x = x / scrollable_width
+        scrollable_height = layout.height - rv.height
+        if scrollable_height:  # avoids ZeroDivisionError
+            rv.scroll_y = y / scrollable_height
+        clock.tick()
+        return {
+            layout.get_view_index_at(c.center): tuple(c.pos)
+            for c in layout.children
+        }
+
+    # |---|---|---|---|
+    # |   | 1 | 2 |   |
+    # |---|---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(4, None), (None, 1), (4, 1)])
+    @pytest.mark.parametrize("orientation", "lr-tb lr-bt tb-lr bt-lr".split())
+    def test_4x1_lr(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {1: (100, 0), 2: (200, 0)} == self.compute_layout(
+            n_data=4, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            scroll_to=(150, 0), clock=kivy_clock)
+
+    # |---|---|---|---|
+    # |   | 2 | 1 |   |
+    # |---|---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(4, None), (None, 1), (4, 1)])
+    @pytest.mark.parametrize("orientation", "rl-tb rl-bt tb-rl bt-rl".split())
+    def test_4x1_rl(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {1: (200, 0), 2: (100, 0)} == self.compute_layout(
+            n_data=4, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            scroll_to=(150, 0), clock=kivy_clock)
+
+    # |---|
+    # |   |
+    # |---|
+    # | 1 |
+    # |---|
+    # | 2 |
+    # |---|
+    # |   |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 4), (1, 4)])
+    @pytest.mark.parametrize("orientation", "tb-lr tb-rl lr-tb rl-tb".split())
+    def test_1x4_tb(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {1: (0, 200), 2: (0, 100)} == self.compute_layout(
+            n_data=4, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            scroll_to=(0, 150), clock=kivy_clock)
+
+    # |---|
+    # |   |
+    # |---|
+    # | 2 |
+    # |---|
+    # | 1 |
+    # |---|
+    # |   |
+    # |---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(1, None), (None, 4), (1, 4)])
+    @pytest.mark.parametrize("orientation", "bt-lr bt-rl lr-bt rl-bt".split())
+    def test_1x4_bt(self, kivy_clock, orientation, n_cols, n_rows):
+        assert {1: (0, 100), 2: (0, 200)} == self.compute_layout(
+            n_data=4, orientation=orientation, n_cols=n_cols, n_rows=n_rows,
+            scroll_to=(0, 150), clock=kivy_clock)
+
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    # |   | 4 | 5 |
+    # |---|---|---|
+    # |   | 7 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_lr_tb(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (200, 100), 7: (100, 0)} == \
+            self.compute_layout(
+                n_data=8, orientation='lr-tb', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(150, 50), clock=kivy_clock)
+
+    # |---|---|
+    # |   | 7 |
+    # |---|---|---|
+    # |   | 4 | 5 |
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_lr_bt(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (200, 100), 7: (100, 200)} == \
+            self.compute_layout(
+                n_data=8, orientation='lr-bt', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(150, 150), clock=kivy_clock)
+
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    # | 5 | 4 |   |
+    # |---|---|---|
+    #     | 7 |   |
+    #     |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_rl_tb(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (0, 100), 7: (100, 0)} == \
+            self.compute_layout(
+                n_data=8, orientation='rl-tb', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(50, 50), clock=kivy_clock)
+
+    #     |---|---|
+    #     | 7 |   |
+    # |---|---|---|
+    # | 5 | 4 |   |
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_rl_bt(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (0, 100), 7: (100, 200)} == \
+            self.compute_layout(
+                n_data=8, orientation='rl-bt', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(50, 150), clock=kivy_clock)
+
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    # |   | 4 | 7 |
+    # |---|---|---|
+    # |   | 5 |
+    # |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_tb_lr(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (100, 0), 7: (200, 100)} == \
+            self.compute_layout(
+                n_data=8, orientation='tb-lr', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(150, 50), clock=kivy_clock)
+
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    # | 7 | 4 |   |
+    # |---|---|---|
+    #     | 5 |   |
+    #     |---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_tb_rl(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (100, 0), 7: (0, 100)} == \
+            self.compute_layout(
+                n_data=8, orientation='tb-rl', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(50, 50), clock=kivy_clock)
+
+    # |---|---|
+    # |   | 5 |
+    # |---|---|---|
+    # |   | 4 | 7 |
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_bt_lr(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (100, 200), 7: (200, 100)} == \
+            self.compute_layout(
+                n_data=8, orientation='bt-lr', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(150, 150), clock=kivy_clock)
+
+    #     |---|---|
+    #     | 5 |   |
+    # |---|---|---|
+    # | 7 | 4 |   |
+    # |---|---|---|
+    # |   |   |   |
+    # |---|---|---|
+    @pytest.mark.parametrize("n_cols, n_rows", [(3, None), (None, 3), (3, 3)])
+    def test_3x3_bt_rl(self, kivy_clock, n_cols, n_rows):
+        assert {4: (100, 100), 5: (100, 200), 7: (0, 100)} == \
+            self.compute_layout(
+                n_data=8, orientation='bt-rl', n_cols=n_cols, n_rows=n_rows,
+                scroll_to=(50, 150), clock=kivy_clock)
diff --git a/kivy/tests/test_uix_relativelayout.py b/kivy/tests/test_uix_relativelayout.py
new file mode 100644
index 0000000..2e86350
--- /dev/null
+++ b/kivy/tests/test_uix_relativelayout.py
@@ -0,0 +1,30 @@
+'''
+uix.relativelayout tests
+========================
+'''
+
+import unittest
+
+from kivy.base import EventLoop
+from kivy.tests import UTMotionEvent
+from kivy.uix.relativelayout import RelativeLayout
+
+
+class UixRelativeLayoutTest(unittest.TestCase):
+
+    def test_relativelayout_on_touch_move(self):
+        EventLoop.ensure_window()
+        rl = RelativeLayout()
+        EventLoop.window.add_widget(rl)
+        touch = UTMotionEvent("unittest", 1, {"x": .5, "y": .5})
+        EventLoop.post_dispatch_input("begin", touch)
+        touch.move({"x": .6, "y": .4})
+        EventLoop.post_dispatch_input("update", touch)
+        EventLoop.post_dispatch_input("end", touch)
+
+    def test_relativelayout_coordinates(self):
+        EventLoop.ensure_window()
+        rl = RelativeLayout(pos=(100, 100))
+        EventLoop.window.add_widget(rl)  # do_layout() called
+        self.assertEqual(rl.to_parent(50, 50), (150, 150))
+        self.assertEqual(rl.to_local(50, 50), (-50, -50))
diff --git a/kivy/tests/test_uix_scrollview.py b/kivy/tests/test_uix_scrollview.py
new file mode 100644
index 0000000..fa18b86
--- /dev/null
+++ b/kivy/tests/test_uix_scrollview.py
@@ -0,0 +1,358 @@
+from kivy.tests.common import GraphicUnitTest
+
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.scrollview import ScrollView
+from kivy.uix.label import Label
+from kivy.base import EventLoop
+from kivy.clock import Clock
+from kivy.tests.common import UTMotionEvent
+
+from time import sleep
+from itertools import count
+
+DEBUG = False
+touch_id = count()
+
+
+class _TestGrid(GridLayout):
+    def __init__(self, **kwargs):
+        kwargs['cols'] = 1
+        kwargs['spacing'] = 10
+        kwargs['size_hint'] = (None, None)
+        super(_TestGrid, self).__init__(**kwargs)
+        self.bind(minimum_height=self.setter('height'))
+        self.bind(minimum_width=self.setter('width'))
+
+        for i in range(10):
+            self.add_widget(Label(
+                size_hint=(None, None),
+                height=100, width=1000,
+                text=str(i)
+            ))
+
+
+class _TestScrollbarHorizontal(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_y'] = False
+        super(_TestScrollbarHorizontal, self).__init__(**kwargs)
+
+
+class _TestScrollbarVertical(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_x'] = False
+        super(_TestScrollbarVertical, self).__init__(**kwargs)
+
+
+class _TestScrollbarBoth(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_width'] = 20
+        super(_TestScrollbarBoth, self).__init__(**kwargs)
+
+
+class _TestScrollbarHorizontalMargin(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_margin'] = 40
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_y'] = False
+        super(_TestScrollbarHorizontalMargin, self).__init__(**kwargs)
+
+
+class _TestScrollbarVerticalMargin(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_margin'] = 40
+        kwargs['bar_width'] = 20
+        kwargs['do_scroll_x'] = False
+        super(_TestScrollbarVerticalMargin, self).__init__(**kwargs)
+
+
+class _TestScrollbarBothMargin(ScrollView):
+    def __init__(self, **kwargs):
+        kwargs['scroll_type'] = ["bars"]
+        kwargs['bar_margin'] = 40
+        kwargs['bar_width'] = 20
+        super(_TestScrollbarBothMargin, self).__init__(**kwargs)
+
+
+class ScrollViewTestCase(GraphicUnitTest):
+    framecount = 0
+
+    def process_points(self, scroll, points):
+        win = EventLoop.window
+        dt = 0.02
+
+        for point in points:
+            if DEBUG:
+                print('point:', point, scroll.scroll_x, scroll.scroll_y)
+                Clock.schedule_once(lambda *dt: sleep(0.5), 0)
+                self.render(scroll)
+
+            x, y, nx, ny, pos_x, pos_y, border_check = point
+            scroll.bar_pos = (pos_x, pos_y)
+
+            touch = UTMotionEvent("unittest", next(touch_id), {
+                "x": x / float(win.width),
+                "y": y / float(win.height),
+            })
+
+            # we start with the default top-left corner
+            self.assertAlmostEqual(scroll.scroll_x, 0.0, delta=dt)
+            self.assertAlmostEqual(scroll.scroll_y, 1.0, delta=dt)
+
+            # check the collision with the margin empty area
+            if border_check:
+                EventLoop.post_dispatch_input("begin", touch)
+                touch.move({
+                    "x": nx / float(win.width),
+                    "y": ny / float(win.height)
+                })
+                EventLoop.post_dispatch_input("update", touch)
+                EventLoop.post_dispatch_input("end", touch)
+
+                self.assertAlmostEqual(scroll.scroll_x, 0.0, delta=dt)
+                self.assertAlmostEqual(scroll.scroll_y, 1.0, delta=dt)
+                return
+
+            EventLoop.post_dispatch_input("begin", touch)
+            touch.move({
+                "x": nx / float(win.width),
+                "y": ny / float(win.height)
+            })
+            EventLoop.post_dispatch_input("update", touch)
+            EventLoop.post_dispatch_input("end", touch)
+
+            if DEBUG:
+                print(scroll.scroll_x, scroll.scroll_y)
+                Clock.schedule_once(lambda *dt: sleep(0.5), 0)
+                self.render(scroll)
+
+            # check the scroll position
+            self.assertAlmostEqual(
+                scroll.scroll_x, 0.0 if x == nx else 1.0,
+                delta=dt
+            )
+            self.assertAlmostEqual(
+                scroll.scroll_y, 1.0 if y == ny else 0.0,
+                delta=dt
+            )
+
+            # reset scroll to original state
+            scroll.scroll_x = 0.0
+            scroll.scroll_y = 1.0
+
+    def test_scrollbar_horizontal(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarHorizontal()
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        points = [
+            [left, bottom, right, bottom, 'bottom', 'right', False],
+            [left, top, right, top, 'top', 'right', False]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_vertical(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarVertical()
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        points = [
+            [right, top, right, bottom, 'bottom', 'right', False],
+            [left, top, left, bottom, 'bottom', 'left', False]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_both(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarBoth()
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        points = [
+            [left, bottom, right, bottom, 'bottom', 'right', False],
+            [left, top, right, top, 'top', 'right', False],
+            [right, top, right, bottom, 'bottom', 'right', False],
+            [left, top, left, bottom, 'bottom', 'left', False]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_horizontal_margin(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarHorizontalMargin()
+        margin = scroll.bar_margin
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        # touch in the half of the bar
+        m = margin + scroll.bar_width / 2.0
+        points = [
+            [left, bottom + m, right, bottom + m, 'bottom', 'right', False],
+            [left, top - m, right, top - m, 'top', 'right', False],
+            [left, bottom, right, bottom, 'bottom', 'right', True],
+            [left, top, right, top, 'top', 'right', True]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_vertical_margin(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarVerticalMargin()
+        margin = scroll.bar_margin
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        # touch in the half of the bar
+        m = margin + scroll.bar_width / 2.0
+        points = [
+            [right - m, top, right - m, bottom, 'bottom', 'right', False],
+            [left + m, top, left + m, bottom, 'bottom', 'left', False],
+            [right, top, right, bottom, 'bottom', 'right', True],
+            [left, top, left, bottom, 'bottom', 'left', True]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_scrollbar_both_margin(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = _TestScrollbarBothMargin()
+        margin = scroll.bar_margin
+        scroll.add_widget(grid)
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        left, right = scroll.to_window(scroll.x, scroll.right)
+        bottom, top = scroll.to_window(scroll.y, scroll.top)
+
+        # touch in the half of the bar
+        m = margin + scroll.bar_width / 2.0
+        points = [
+            [left, bottom + m, right, bottom + m, 'bottom', 'right', False],
+            [left, top - m, right, top - m, 'top', 'right', False],
+            [right - m, top, right - m, bottom, 'bottom', 'right', False],
+            [left + m, top, left + m, bottom, 'bottom', 'left', False],
+            [left, bottom, right, bottom, 'bottom', 'right', True],
+            [left, top, right, top, 'top', 'right', True],
+            [right, top, right, bottom, 'bottom', 'right', True],
+            [left, top, left, bottom, 'bottom', 'left', True]
+        ]
+        self.process_points(scroll, points)
+        self.render(scroll)
+
+    def test_smooth_scroll_end(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        grid = _TestGrid()
+        scroll = ScrollView(smooth_scroll_end=10)
+
+        assert scroll.smooth_scroll_end == 10
+        scroll.add_widget(grid)
+
+        # XXX this shouldn't be needed, but previous tests apparently
+        # don't cleanup
+        while win.children:
+            win.remove_widget(win.children[0])
+
+        win.add_widget(scroll)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        e = scroll.effect_y
+        assert e.velocity == 0
+
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": scroll.center_x / float(win.width),
+            "y": scroll.center_y / float(win.height),
+        })
+
+        touch.profile.append('button')
+        touch.button = 'scrollup'
+
+        EventLoop.post_dispatch_input("begin", touch)
+        # EventLoop.post_dispatch_input("update", touch)
+        assert e.velocity == 10 * scroll.scroll_wheel_distance
+        EventLoop.idle()
+        assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance
+        EventLoop.post_dispatch_input("end", touch)
+        EventLoop.idle()
+        assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance
+
+        # wait for velocity to die off
+        while e.velocity:
+            EventLoop.idle()
+
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": scroll.center_x / float(win.width),
+            "y": scroll.center_y / float(win.height),
+        })
+        touch.profile.append('button')
+        touch.button = 'scrolldown'
+
+        EventLoop.post_dispatch_input("begin", touch)
+        # EventLoop.post_dispatch_input("update", touch)
+        assert e.velocity == -10 * scroll.scroll_wheel_distance
+        EventLoop.idle()
+        assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance
+        EventLoop.post_dispatch_input("end", touch)
+        EventLoop.idle()
+        assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_uix_slider.py b/kivy/tests/test_uix_slider.py
new file mode 100644
index 0000000..2d2389f
--- /dev/null
+++ b/kivy/tests/test_uix_slider.py
@@ -0,0 +1,156 @@
+from kivy.tests.common import GraphicUnitTest, UTMotionEvent
+
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.slider import Slider
+from kivy.base import EventLoop
+
+
+class _TestSliderHandle(Slider):
+    def __init__(self, **kwargs):
+        super(_TestSliderHandle, self).__init__(**kwargs)
+        self.sensitivity = 'handle'
+
+
+class _TestSliderAll(Slider):
+    def __init__(self, **kwargs):
+        super(_TestSliderAll, self).__init__(**kwargs)
+        self.sensitivity = 'all'
+
+
+class SliderMoveTestCase(GraphicUnitTest):
+    framecount = 0
+
+    def setUp(self):
+        # kill KV lang logging (too long test)
+        import kivy.lang.builder as builder
+
+        if not hasattr(self, '_trace'):
+            self._trace = builder.trace
+
+        self.builder = builder
+        builder.trace = lambda *_, **__: None
+        super(SliderMoveTestCase, self).setUp()
+
+    def tearDown(self, *args, **kwargs):
+        # add the logging back
+        import kivy.lang.builder as builder
+        builder.trace = self._trace
+        super(SliderMoveTestCase, self).tearDown(*args, **kwargs)
+
+    def test_slider_move(self):
+        EventLoop.ensure_window()
+        win = EventLoop.window
+        layout = BoxLayout(orientation='vertical')
+
+        s_handle = _TestSliderHandle()
+        s_all = _TestSliderAll()
+        layout.add_widget(s_handle)
+        layout.add_widget(s_all)
+        win.add_widget(layout)
+
+        # get widgets ready
+        EventLoop.idle()
+
+        cur1 = s_handle.children[0]
+        cur2 = s_all.children[0]
+
+        h1 = cur1.to_window(*cur1.center)[1]
+        h2 = h1 - s_handle.cursor_height
+        h3 = cur2.to_window(*cur2.center)[1]
+        h4 = h3 - s_all.cursor_height
+
+        w1 = cur1.to_window(*cur1.center)[0]
+        w2 = cur2.to_window(*cur2.center)[0]
+        wh = win.width / 2.0
+        dt = 2
+
+        # default pos, new pos, slider ID
+        points = [
+            [w1, h1, wh, h1, 'handle'],
+            [w1, h2, wh, h2, 'handle'],
+            [w2, h3, wh, h3, 'all'],
+            [w2, h4, wh, h4, 'all'],
+        ]
+
+        for point in points:
+            x, y, nx, ny, id = point
+
+            # custom touch
+            touch = UTMotionEvent("unittest", 1, {
+                "x": x / float(win.width),
+                "y": y / float(win.height),
+            })
+
+            # touch down
+            EventLoop.post_dispatch_input("begin", touch)
+
+            if id == 'handle':
+                # touch on handle
+                if x == w1 and y == h1:
+                    self.assertAlmostEqual(
+                        s_handle.value, 0.0,
+                        delta=dt
+                    )
+                # touch in widget area (ignored, previous value)
+                elif x == w1 and y == h2:
+                    self.assertAlmostEqual(
+                        s_handle.value, 50.0,
+                        delta=dt
+                    )
+            elif id == 'all':
+                # touch on handle:
+                if x == w1 and y == h3:
+                    self.assertAlmostEqual(
+                        s_all.value, 0.0,
+                        delta=dt
+                    )
+                # touch in widget area
+                elif x == w1 and y == h4:
+                    self.assertAlmostEqual(
+                        s_all.value, 0.0,
+                        delta=dt
+                    )
+
+            # move from default to new pos
+            touch.move({
+                "x": nx / float(win.width),
+                "y": ny / float(win.height)
+            })
+            EventLoop.post_dispatch_input("update", touch)
+
+            if id == 'handle':
+                # move from handle to center
+                if nx == wh and ny == h1:
+                    self.assertAlmostEqual(
+                        s_handle.value, 50.0,
+                        delta=dt
+                    )
+                # move to center (ignored, previous value)
+                elif nx == wh and ny == h2:
+                    self.assertAlmostEqual(
+                        s_handle.value, 50.0,
+                        delta=dt
+                    )
+            elif id == 'all':
+                # touch on handle:
+                if nx == wh and ny == h3:
+                    self.assertAlmostEqual(
+                        s_all.value, 50.0,
+                        delta=dt
+                    )
+                # touch in widget area
+                elif nx == wh and ny == h4:
+                    self.assertAlmostEqual(
+                        s_all.value, 50.0,
+                        delta=dt
+                    )
+
+            # touch up
+            EventLoop.post_dispatch_input("end", touch)
+
+        self.render(layout)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_uix_stacklayout.py b/kivy/tests/test_uix_stacklayout.py
new file mode 100644
index 0000000..1baa095
--- /dev/null
+++ b/kivy/tests/test_uix_stacklayout.py
@@ -0,0 +1,120 @@
+'''
+uix.stacklayout tests
+=====================
+'''
+
+import unittest
+
+from kivy.uix.stacklayout import StackLayout
+from kivy.uix.widget import Widget
+
+
+class UixStackLayoutTest(unittest.TestCase):
+
+    def test_stacklayout_no_children(self):
+        sl = StackLayout()
+        sl.do_layout()
+
+    def test_stacklayout_default(self):
+        # Default orientation is lr-tb.
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [0, sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, 0])
+        self.assertEqual(wgts[3].pos, [sl.width / 2., 0])
+
+    def test_stacklayout_fixed_size(self):
+        sl = StackLayout()
+        wgts = [Widget(size=(50, 50), size_hint=(None, None))
+                for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [0, sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, 0])
+        self.assertEqual(wgts[3].pos, [sl.width / 2., 0])
+
+    def test_stacklayout_orientation_btrl(self):
+        # Default orientation is lr-tb.
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.orientation = 'bt-rl'
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [sl.width / 2., 0])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, 0])
+        self.assertEqual(wgts[3].pos, [0, sl.height / 2.])
+
+    def test_stacklayout_orientation_rlbt(self):
+        # Default orientation is lr-tb.
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.orientation = 'rl-bt'
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [sl.width / 2., 0])
+        self.assertEqual(wgts[1].pos, [0, 0])
+        self.assertEqual(wgts[2].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[3].pos, [0, sl.height / 2.])
+
+    def test_stacklayout_padding(self):
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.padding = 5.
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [5., sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2., sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [5., 5.])
+        self.assertEqual(wgts[3].pos, [sl.width / 2., 5.])
+
+    def test_stacklayout_spacing(self):
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.5, .5)) for i in range(4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.spacing = 10
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [0, sl.height / 2.])
+        self.assertEqual(wgts[1].pos, [sl.width / 2. + 5, sl.height / 2.])
+        self.assertEqual(wgts[2].pos, [0, -10])
+        self.assertEqual(wgts[3].pos, [sl.width / 2. + 5, -10])
+
+    def test_stacklayout_overflow(self):
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(.2 * i, .2 * i)) for i in range(1, 4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.padding = 5
+        sl.spacing = 5
+        sl.do_layout()
+
+        self.assertEqual(wgts[0].pos, [5, 77])
+        self.assertEqual(wgts[1].pos, [27, 59])
+        # floating point error, requires almost equal
+        self.assertAlmostEqual(wgts[2].pos[0], 5)
+        self.assertAlmostEqual(wgts[2].pos[1], 0)
+
+    def test_stacklayout_nospace(self):
+        # happens when padding is too big
+        sl = StackLayout()
+        wgts = [Widget(size_hint=(1., .25)) for i in range(1, 4)]
+        for wgt in wgts:
+            sl.add_widget(wgt)
+        sl.padding = 10
+        sl.do_layout()
diff --git a/kivy/tests/test_uix_textinput.py b/kivy/tests/test_uix_textinput.py
new file mode 100644
index 0000000..a9cfcfb
--- /dev/null
+++ b/kivy/tests/test_uix_textinput.py
@@ -0,0 +1,564 @@
+'''
+uix.textinput tests
+========================
+'''
+
+import unittest
+from itertools import count
+
+from kivy.core.window import Window
+from kivy.tests.common import GraphicUnitTest, UTMotionEvent
+from kivy.uix.textinput import TextInput
+from kivy.uix.widget import Widget
+from kivy.clock import Clock
+
+touch_id = count()
+
+
+class TextInputTest(unittest.TestCase):
+
+    def test_focusable_when_disabled(self):
+        ti = TextInput()
+        ti.disabled = True
+        ti.focused = True
+        ti.bind(focus=self.on_focused)
+
+    def on_focused(self, instance, value):
+        self.assertTrue(instance.focused, value)
+
+    def test_wordbreak(self):
+        self.test_txt = "Firstlongline\n\nSecondveryverylongline"
+
+        ti = TextInput(width='30dp', size_hint_x=None)
+        ti.bind(text=self.on_text)
+        ti.text = self.test_txt
+
+    def on_text(self, instance, value):
+        # Check if text is modified while recreating from lines and lines_flags
+        self.assertEqual(instance.text, self.test_txt)
+
+        # Check if wordbreaking is correctly done
+        # If so Secondvery... should start from the 7th line
+        pos_S = self.test_txt.index('S')
+        self.assertEqual(instance.get_cursor_from_index(pos_S), (0, 6))
+
+
+class TextInputIMETest(unittest.TestCase):
+
+    def test_ime(self):
+        empty_ti = TextInput()
+        empty_ti.focused = True
+        ti = TextInput(text='abc')
+        Window.dispatch('on_textedit', 'ㅎ')
+        self.assertEqual(empty_ti.text, 'ㅎ')
+        self.assertEqual(ti.text, 'abc')
+        ti.focused = True
+        Window.dispatch('on_textedit', 'ㅎ')
+        self.assertEqual(ti.text, 'abcㅎ')
+        Window.dispatch('on_textedit', '하')
+        self.assertEqual(ti.text, 'abc하')
+        Window.dispatch('on_textedit', '핫')
+        Window.dispatch('on_textedit', '')
+        Window.dispatch('on_textinput', '하')
+        Window.dispatch('on_textedit', 'ㅅ')
+        Window.dispatch('on_textedit', '세')
+        self.assertEqual(ti.text, 'abc하세')
+
+
+class TextInputGraphicTest(GraphicUnitTest):
+    def test_text_validate(self):
+        ti = TextInput(multiline=False)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertFalse(ti.multiline)
+        self.assertTrue(ti.focus)
+        self.assertTrue(ti.text_validate_unfocus)
+
+        ti.validate_test = None
+
+        ti.bind(on_text_validate=lambda *_: setattr(
+            ti, 'validate_test', True
+        ))
+        ti._key_down(
+            (
+                None,     # displayed_str
+                None,     # internal_str
+                'enter',  # internal_action
+                1         # scale
+            ),
+            repeat=False
+        )
+        self.assertTrue(ti.validate_test)
+        self.assertFalse(ti.focus)
+
+        ti.validate_test = None
+        ti.text_validate_unfocus = False
+        ti.focus = True
+        self.assertTrue(ti.focus)
+
+        ti._key_down(
+            (None, None, 'enter', 1),
+            repeat=False
+        )
+        self.assertTrue(ti.validate_test)
+        self.assertTrue(ti.focus)
+
+    def test_selection_enter_multiline(self):
+        text = 'multiline\ntext'
+        ti = TextInput(multiline=True, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        # multiline
+        # text$
+        self.assertEqual(
+            ti.cursor, (
+                len(text.split('\n')[-1]),
+                len(text.split('\n')) - 1
+            )
+        )
+
+        # move and check position
+        # mult$iline
+        # text
+        ti._key_down(     # push selection
+            (
+                None,     # displayed_str
+                None,     # internal_str
+                'shift',  # internal_action
+                1         # scale
+            ),
+            repeat=False
+        )
+        ti._key_down(
+            (None, None, 'cursor_up', 1),
+            repeat=False
+        )
+        # pop selection
+        ti._key_up(
+            (None, None, 'shift', 1),
+            repeat=False
+        )
+        self.assertEqual(
+            ti.cursor, (
+                len(text.split('\n')[-1]),
+                len(text.split('\n')) - 2
+            )
+        )
+        self.assertEqual(ti.text, text)
+
+        # overwrite selection with \n
+        ti._key_down(
+            (None, None, 'enter', 1),
+            repeat=False
+        )
+        self.assertEqual(ti.text, text[:4] + '\n')
+
+    def test_selection_enter_singleline(self):
+        text = 'singleline'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        # singleline$
+        self.assertEqual(ti.cursor, (len(text), 0))
+
+        # move and check position
+        # single$line
+        steps = 4
+        options = ((
+            'enter',
+            text
+        ), (
+            'backspace',
+            text[:len(text) - steps]
+        ))
+        for key, txt in options:
+            # push selection
+            ti._key_down((None, None, 'shift', 1), repeat=False)
+            for _ in range(steps):
+                ti._key_down(
+                    (None, None, 'cursor_left', 1),
+                    repeat=False
+                )
+
+            # pop selection
+            ti._key_up((None, None, 'shift', 1), repeat=False)
+            self.assertEqual(
+                ti.cursor, (len(text[:-steps]), 0)
+            )
+            self.assertEqual(ti.text, text)
+
+            # try to overwrite selection with \n
+            # (shouldn't work because single line)
+            ti._key_down(
+                (None, None, key, 1),
+                repeat=False
+            )
+            self.assertEqual(ti.text, txt)
+            ti._key_down((None, None, 'cursor_end', 1), repeat=False)
+
+    def test_del(self):
+        text = 'some_random_text'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        self.assertEqual(ti.cursor, (len(text), 0))
+
+        steps_skip = 2
+        steps_select = 4
+        del_key = 'del'
+
+        for _ in range(steps_skip):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+        # cursor at the place of ^
+        # some_random_te^xt
+
+        # push selection
+        ti._key_down((None, None, 'shift', 1), repeat=False)
+        for _ in range(steps_select):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+
+        # pop selection
+        ti._key_up((None, None, 'shift', 1), repeat=False)
+
+        # cursor at the place of ^, selection between * chars
+        # some_rando*^m_te*xt
+
+        self.assertEqual(
+            ti.cursor, (len(text[:-steps_select - steps_skip]), 0)
+        )
+        self.assertEqual(ti.text, text)
+
+        ti._key_down(
+            (None, None, del_key, 1),
+            repeat=False
+        )
+        # cursor now at: some_rando^xt
+        self.assertEqual(ti.text, 'some_randoxt')
+
+        ti._key_down(
+            (None, None, del_key, 1),
+            repeat=False
+        )
+        self.assertEqual(ti.text, 'some_randot')
+
+    def test_escape(self):
+        text = 'some_random_text'
+        escape_key = 'escape'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        ti._key_down(
+            (None, None, escape_key, 1),
+            repeat=False
+        )
+        self.assertFalse(ti.focus)
+        self.assertEqual(ti.text, text)
+
+    def test_no_shift_cursor_arrow_on_selection(self):
+        text = 'some_random_text'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        self.assertEqual(ti.cursor, (len(text), 0))
+
+        steps_skip = 2
+        steps_select = 4
+
+        for _ in range(steps_skip):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+        # cursor at the place of ^
+        # some_random_te^xt
+
+        # push selection
+        ti._key_down((None, None, 'shift', 1), repeat=False)
+        for _ in range(steps_select):
+            ti._key_down(
+                (None, None, 'cursor_left', 1),
+                repeat=False
+            )
+
+        # pop selection
+        ti._key_up((None, None, 'shift', 1), repeat=False)
+
+        # cursor at the place of ^, selection between * chars
+        # some_rando*^m_te*xt
+
+        ti._key_down(
+            (None, None, 'cursor_right', 1),
+            repeat=False
+        )
+        self.assertEqual(ti.cursor, (len(text) - steps_skip, 0))
+
+    def test_cursor_movement_control(self):
+        text = "these are\nmany words"
+        ti = TextInput(multiline=True, text=text)
+
+        ti.focus = True
+
+        self.render(ti)
+        self.assertTrue(ti.focus)
+
+        # assert cursor is here:
+        self.assertEqual(
+            ti.cursor, (
+                len(text.split('\n')[-1]),
+                len(text.split('\n')) - 1
+            )
+        )
+
+        options = (
+                ('cursor_left', (5, 1)),
+                ('cursor_left', (0, 1)),
+                ('cursor_left', (6, 0)),
+                ('cursor_right', (9, 0)),
+                ('cursor_right', (4, 1)))
+
+        for key, pos in options:
+            ti._key_down((None, None, 'ctrl_L', 1), repeat=False)
+            ti._key_down((None, None, key, 1), repeat=False)
+
+            self.assertEqual(ti.cursor, pos)
+
+            ti._key_up((None, None, 'ctrl_L', 1), repeat=False)
+
+    def test_cursor_blink(self):
+        ti = TextInput(cursor_blink=True)
+        ti.focus = True
+
+        # overwrite blinking event, because too long delay
+        ti._do_blink_cursor_ev = Clock.create_trigger(
+            ti._do_blink_cursor, 0.01, interval=True
+        )
+
+        self.render(ti)
+
+        # from kwargs cursor_blink == True
+        self.assertTrue(ti.cursor_blink)
+        self.assertTrue(ti._do_blink_cursor_ev.is_triggered)
+
+        # set whether to blink & check if resets
+        ti.cursor_blink = False
+        for i in range(30):
+            self.advance_frames(int(0.01 * Clock._max_fps) + 1)
+            self.assertFalse(ti._do_blink_cursor_ev.is_triggered)
+
+            # no blinking, cursor visible
+            self.assertFalse(ti._cursor_blink)
+
+        ti.cursor_blink = True
+        self.assertTrue(ti.cursor_blink)
+        for i in range(30):
+            self.advance_frames(int(0.01 * Clock._max_fps) + 1)
+            self.assertTrue(ti._do_blink_cursor_ev.is_triggered)
+
+    def test_visible_lines_range(self):
+        ti = self.make_scrollable_text_input()
+        assert ti._visible_lines_range == (20, 30)
+
+        ti.height = ti_height_for_x_lines(ti, 2.5)
+        ti.do_cursor_movement('cursor_home', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 3)
+
+        ti.height = ti_height_for_x_lines(ti, 0)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 0)
+
+    def test_keyboard_scroll(self):
+        ti = self.make_scrollable_text_input()
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_home', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+        assert prev_cursor != ti.cursor
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_down', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (1, 11)
+        # cursor position (col and row) should not be
+        # changed by "ctrl + cursor_down" and "ctrl + cursor_up"
+        assert prev_cursor == ti.cursor
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_up', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+        assert prev_cursor == ti.cursor
+
+        prev_cursor = ti.cursor
+        ti.do_cursor_movement('cursor_end', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (20, 30)
+        assert prev_cursor != ti.cursor
+
+    def test_scroll_doesnt_move_cursor(self):
+        ti = self.make_scrollable_text_input()
+
+        from kivy.base import EventLoop
+        win = EventLoop.window
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": ti.center_x / float(win.width),
+            "y": ti.center_y / float(win.height),
+        })
+        touch.profile.append('button')
+        touch.button = 'scrolldown'
+
+        prev_cursor = ti.cursor
+        assert ti._visible_lines_range == (20, 30)
+        EventLoop.post_dispatch_input("begin", touch)
+        EventLoop.post_dispatch_input("end", touch)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (19, 29)
+        assert ti.cursor == prev_cursor
+
+    def test_vertical_scroll_doesnt_depend_on_lines_rendering(self):
+        # TextInput.on_touch_down was checking the possibility to scroll_up
+        # using the positions of the rendered lines' rects. These positions
+        # don't change when the lines are skipped (e.g. during fast scroll
+        # or ctrl+cursor_home) which lead to scroll freeze
+        ti = self.make_scrollable_text_input()
+
+        # move viewport to the first line
+        ti.do_cursor_movement('cursor_home', control=True)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+
+        from kivy.base import EventLoop
+        win = EventLoop.window
+
+        # slowly scroll to the last line to render all lines at least once
+        for _ in range(30):  # little overscroll is important for detection
+            touch = UTMotionEvent("unittest", next(touch_id), {
+                "x": ti.center_x / float(win.width),
+                "y": ti.center_y / float(win.height),
+            })
+            touch.profile.append('button')
+            touch.button = 'scrollup'
+
+            EventLoop.post_dispatch_input("begin", touch)
+            EventLoop.post_dispatch_input("end", touch)
+            self.advance_frames(1)
+        assert ti._visible_lines_range == (20, 30)
+
+        # jump to the first line again
+        ti.do_cursor_movement('cursor_home', control=True)
+
+        # temp fix: only change of cursor position triggers update as for now
+        ti._trigger_update_graphics()
+
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (0, 10)
+
+        # scrolling up should work now
+        touch = UTMotionEvent("unittest", next(touch_id), {
+            "x": ti.center_x / float(win.width),
+            "y": ti.center_y / float(win.height),
+        })
+        touch.profile.append('button')
+        touch.button = 'scrollup'
+        EventLoop.post_dispatch_input("begin", touch)
+        EventLoop.post_dispatch_input("end", touch)
+        self.advance_frames(1)
+        assert ti._visible_lines_range == (1, 11)
+
+    def test_selectall_copy_paste(self):
+        text = 'test'
+        ti = TextInput(multiline=False, text=text)
+        ti.focus = True
+        self.render(ti)
+
+        from kivy.base import EventLoop
+        win = EventLoop.window
+
+        # select all
+        # win.dispatch(event_name, key, scancode, kstr, modifiers)
+        win.dispatch('on_key_down', 97, 4, 'a', ['capslock', 'ctrl'])
+        win.dispatch('on_key_up', 97, 4)
+        self.advance_frames(1)
+
+        # copy
+        win.dispatch('on_key_down', 99, 6, 'c',
+                     ['capslock', 'numlock', 'ctrl'])
+        win.dispatch('on_key_up', 99, 6)
+        self.advance_frames(1)
+
+        # home
+        win.dispatch('on_key_down', 278, 74, None, ['capslock'])
+        win.dispatch('on_key_up', 278, 74)
+        self.advance_frames(1)
+
+        # paste
+        win.dispatch('on_key_down', 118, 25, 'v', ['numlock', 'ctrl'])
+        win.dispatch('on_key_up', 118, 25)
+        self.advance_frames(1)
+
+        assert ti.text == 'testtest'
+
+    def make_scrollable_text_input(self, num_of_lines=30, n_lines_to_show=10):
+        """Prepare and start rendering the scrollable text input.
+
+           num_of_lines -- amount of dummy lines used as contents
+           n_lines_to_show -- amount of lines to fit in viewport
+        """
+        # create TextInput instance with dummy contents
+        text = '\n'.join(map(str, range(num_of_lines)))
+        ti = TextInput(text=text)
+        ti.focus = True
+
+        # use container to have flexible TextInput size
+        container = Widget()
+        container.add_widget(ti)
+        self.render(container)
+
+        # change TextInput's size to contain the needed amount of lines
+        ti.height = ti_height_for_x_lines(ti, n_lines_to_show)
+        self.advance_frames(1)
+        return ti
+
+
+def ti_height_for_x_lines(ti, x):
+    """Calculate TextInput height required to display x lines in viewport.
+
+    ti -- TextInput object being used
+    x -- number of lines to display
+    """
+    padding_top = ti.padding[1]
+    padding_bottom = ti.padding[3]
+    return int((ti.line_height + ti.line_spacing) * x
+               + padding_top + padding_bottom)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/kivy/tests/test_uix_translate_coordinates.py b/kivy/tests/test_uix_translate_coordinates.py
new file mode 100644
index 0000000..741243d
--- /dev/null
+++ b/kivy/tests/test_uix_translate_coordinates.py
@@ -0,0 +1,72 @@
+import pytest
+import functools
+
+non_relative_type_widget_cls_names = ('Widget', )
+relative_type_widget_cls_names = (
+    'RelativeLayout', 'Scatter', 'ScrollView',
+)
+all_widget_cls_names = \
+    non_relative_type_widget_cls_names + \
+    relative_type_widget_cls_names
+
+
+@functools.lru_cache(maxsize=1)
+def get_relative_type_widget_classes():
+    from kivy.factory import Factory
+    return tuple(
+        Factory.get(cls_name)
+        for cls_name in relative_type_widget_cls_names
+    )
+
+
+def is_relative_type(widget):
+    return isinstance(widget, get_relative_type_widget_classes())
+
+
+@pytest.mark.parametrize('widget_cls_name', relative_type_widget_cls_names)
+def test_to_local_and_to_parent__relative(widget_cls_name, kivy_clock):
+    from kivy.factory import Factory
+    widget = Factory.get(widget_cls_name)(pos=(100, 100))
+    kivy_clock.tick()
+    assert widget.to_local(0, 0) == (-100, -100)
+    assert widget.to_parent(0, 0) == (100, 100)
+
+
+@pytest.mark.parametrize('widget_cls_name', non_relative_type_widget_cls_names)
+def test_to_local_and_to_parent__not_relative(widget_cls_name, kivy_clock):
+    from kivy.factory import Factory
+    widget = Factory.get(widget_cls_name)(pos=(100, 100))
+    kivy_clock.tick()
+    assert widget.to_local(0, 0) == (0, 0)
+    assert widget.to_parent(0, 0) == (0, 0)
+
+
+@pytest.mark.parametrize('root_widget_cls_name', all_widget_cls_names)
+@pytest.mark.parametrize('target_widget_cls_name', all_widget_cls_names)
+def test_to_window_and_to_widget(
+        root_widget_cls_name, target_widget_cls_name, kivy_clock):
+    from textwrap import dedent
+    from kivy.lang import Builder
+    root = Builder.load_string(dedent('''
+        {}:
+            pos: 100, 0
+
+            # In case the root widget is ScrollView, this cushion is needed,
+            # because ScrollView's direct child is always at pos(0, 0)
+            Widget:
+                pos: 0, 0
+
+                {}:
+                    id: target
+                    pos: 0, 100
+        ''').format(root_widget_cls_name, target_widget_cls_name))
+    kivy_clock.tick()
+    target = root.ids.target
+    if is_relative_type(root):
+        assert target.to_window(*target.pos) == (100, 100)
+        assert target.to_widget(0, 0) == \
+            ((-100, -100) if is_relative_type(target) else (-100, 0))
+    else:
+        assert target.to_window(*target.pos) == (0, 100)
+        assert target.to_widget(0, 0) == \
+            ((0, -100) if is_relative_type(target) else (0, 0))
diff --git a/kivy/tests/test_uix_videoplayer.py b/kivy/tests/test_uix_videoplayer.py
new file mode 100644
index 0000000..48f9f24
--- /dev/null
+++ b/kivy/tests/test_uix_videoplayer.py
@@ -0,0 +1,112 @@
+import pytest
+
+from kivy.tests import async_run, UnitKivyApp, GraphicUnitTest
+from unittest.mock import patch
+
+
+def videoplayer_app():
+    from kivy.app import App
+    from kivy.uix.videoplayer import VideoPlayer
+
+    class TestApp(UnitKivyApp, App):
+        def build(self):
+            root = VideoPlayer()
+            return root
+
+    return TestApp()
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_default_thumbnail(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_thumbnail"
+    ) as mock__load_thumbnail, patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_thumbnail.assert_called_once_with("data/video.png")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_default_annotation(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_annotations.assert_called_once_with("data/video.jsa")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_thumbnail(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_thumbnail"
+    ) as mock__load_thumbnail, patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        kivy_app.root.thumbnail = "data/custom.jpg"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_thumbnail.assert_called_once_with("data/custom.jpg")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_annotation(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations, patch(
+        "kivy.uix.videoplayer.exists"
+    ) as mock_exists:
+        mock_exists.return_value = True
+        kivy_app.root.source = "data/video.mp4"
+        kivy_app.root.annotations = "data/custom.jsa"
+        await kivy_app.wait_clock_frames(2)
+        mock__load_annotations.assert_called_once_with("data/custom.jsa")
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_thumbnail_reset(
+    kivy_app,
+):
+    kivy_app.root.thumbnail = "data/custom.jpg"
+    assert len(kivy_app.root.container.children) != 0
+
+    kivy_app.root.thumbnail = ""
+    assert len(kivy_app.root.container.children) == 0
+
+
+@async_run(app_cls_func=videoplayer_app)
+async def test_custom_annotations_reset_no_fail(
+    kivy_app,
+):
+    with patch(
+        "kivy.uix.videoplayer.VideoPlayer._load_annotations"
+    ) as mock__load_annotations:
+        kivy_app.root.annotations = "data/annotations.jsa"
+
+    kivy_app.root.annotations = ""
+
+if __name__ == "__main__":
+    pytest.main(
+        args=[
+            __file__,
+        ]
+    )
diff --git a/kivy/tests/test_uix_widget.py b/kivy/tests/test_uix_widget.py
new file mode 100644
index 0000000..159a99f
--- /dev/null
+++ b/kivy/tests/test_uix_widget.py
@@ -0,0 +1,137 @@
+from kivy.tests.common import GraphicUnitTest
+
+
+class UIXWidgetTestCase(GraphicUnitTest):
+
+    def test_default_widgets(self):
+        from kivy.uix.button import Button
+        from kivy.uix.slider import Slider
+        r = self.render
+        r(Button())
+        r(Slider())
+
+    def test_button_properties(self):
+        from kivy.uix.button import Button
+        r = self.render
+        # test label attribute inside button
+        r(Button(text='Hello world'))
+        r(Button(text='Multiline\ntext\nbutton'))
+        r(Button(text='Hello world', font_size=42))
+        r(Button(text='This is my first line\nSecond line', halign='center'))
+
+    def test_slider_properties(self):
+        from kivy.uix.slider import Slider
+        r = self.render
+        r(Slider(value=25))
+        r(Slider(value=50))
+        r(Slider(value=100))
+        r(Slider(min=-100, max=100, value=0))
+        r(Slider(orientation='vertical', value=25))
+        r(Slider(orientation='vertical', value=50))
+        r(Slider(orientation='vertical', value=100))
+        r(Slider(orientation='vertical', min=-100, max=100, value=0))
+
+    def test_image_properties(self):
+        from kivy.uix.image import Image
+        from os.path import dirname, join
+        r = self.render
+        filename = join(dirname(__file__), 'test_button.png')
+        r(Image(source=filename))
+
+    def test_add_widget_index_0(self):
+        from kivy.uix.widget import Widget
+        from kivy.uix.button import Button
+        r = self.render
+        root = Widget()
+        a = Button(text='Hello')
+        b = Button(text='World', pos=(50, 10))
+        c = Button(text='Kivy', pos=(10, 50))
+        root.add_widget(a)
+        root.add_widget(b)
+        root.add_widget(c, 0)
+        r(root)
+
+    def test_add_widget_index_1(self):
+        from kivy.uix.widget import Widget
+        from kivy.uix.button import Button
+        r = self.render
+        root = Widget()
+        a = Button(text='Hello')
+        b = Button(text='World', pos=(50, 10))
+        c = Button(text='Kivy', pos=(10, 50))
+        root.add_widget(a)
+        root.add_widget(b)
+        root.add_widget(c, 1)
+        r(root)
+
+    def test_add_widget_index_2(self):
+        from kivy.uix.widget import Widget
+        from kivy.uix.button import Button
+        r = self.render
+        root = Widget()
+        a = Button(text='Hello')
+        b = Button(text='World', pos=(50, 10))
+        c = Button(text='Kivy', pos=(10, 50))
+        root.add_widget(a)
+        root.add_widget(b)
+        root.add_widget(c, 2)
+        r(root)
+
+    def test_widget_root_from_code_with_kv(self):
+        from kivy.lang import Builder
+        from kivy.factory import Factory
+        from kivy.properties import StringProperty
+        from kivy.uix.floatlayout import FloatLayout
+
+        Builder.load_string("""
+<UIXWidget>:
+    Label:
+        text: root.title
+
+<BaseWidget>:
+    CallerWidget:
+""")
+
+        class CallerWidget(FloatLayout):
+
+            def __init__(self, **kwargs):
+                super(CallerWidget, self).__init__(**kwargs)
+                self.add_widget(UIXWidget(title="Hello World"))
+
+        class NestedWidget(FloatLayout):
+            title = StringProperty('aa')
+
+        class UIXWidget(NestedWidget):
+            pass
+
+        class BaseWidget(FloatLayout):
+            pass
+
+        Factory.register('UIXWidget', cls=UIXWidget)
+        Factory.register('CallerWidget', cls=CallerWidget)
+
+        r = self.render
+        root = BaseWidget()
+        r(root)
+
+    '''
+    def test_default_label(self):
+        from kivy.uix.label import Label
+        self.render(Label())
+
+    def test_button_state_down(self):
+        from kivy.uix.button import Button
+        self.render(Button(state='down'))
+
+    def test_label_text(self):
+        from kivy.uix.label import Label
+        self.render(Label(text='Hello world'))
+
+    def test_label_font_size(self):
+        from kivy.uix.label import Label
+        self.render(Label(text='Hello world', font_size=16))
+
+    def test_label_font_size(self):
+        from kivy.uix.label import Label
+        self.render(Label(text='Hello world'))
+    '''
diff --git a/kivy/tests/test_urlrequest.py b/kivy/tests/test_urlrequest.py
new file mode 100644
index 0000000..a9e3ba2
--- /dev/null
+++ b/kivy/tests/test_urlrequest.py
@@ -0,0 +1,158 @@
+'''
+UrlRequest tests
+================
+'''
+import pytest
+import threading
+
+from datetime import datetime
+from time import sleep
+from base64 import b64encode
+import os
+
+
+def wait_request_is_finished(kivy_clock, request, timeout=10):
+    start_time = datetime.now()
+    timed_out = False
+    while not request.is_finished and not timed_out:
+        kivy_clock.tick()
+        sleep(.1)
+        timed_out = (datetime.now() - start_time).total_seconds() > timeout
+    assert request.is_finished
+
+
+def ensure_called_from_thread(queue):
+    """Ensures the callback is called from this thread (main)."""
+    tid = threading.get_ident()
+    assert queue[0][0] == tid
+    assert queue[-2][0] == tid
+    assert queue[-1][0] == tid
+
+
+def check_queue_values(queue):
+    """Helper function verifying the queue contains the expected values."""
+    # we should have 2 progress minimum and one success
+    assert len(queue) >= 3
+
+    assert queue[0][1] == 'progress'
+    assert queue[-2][1] == 'progress'
+    assert queue[-1][1] in ('success', 'redirect')
+
+    assert queue[0][2][0] == 0
+    assert queue[-2][2][0] == queue[-2][2][1]
+
+
+class UrlRequestQueue:
+
+    def __init__(self, queue):
+        self.queue = queue
+
+    def _on_success(self, req, *args):
+        self.queue.append((threading.get_ident(), 'success', args))
+
+    def _on_redirect(self, req, *args):
+        self.queue.append((threading.get_ident(), 'redirect', args))
+
+    def _on_error(self, req, *args):
+        self.queue.append((threading.get_ident(), 'error', args))
+
+    def _on_progress(self, req, *args):
+        self.queue.append((threading.get_ident(), 'progress', args))
+
+
+@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
+def test_callbacks(kivy_clock):
+    from kivy.network.urlrequest import UrlRequest
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    req = UrlRequest('http://google.com',
+                     on_success=obj._on_success,
+                     on_progress=obj._on_progress,
+                     on_error=obj._on_error,
+                     on_redirect=obj._on_redirect,
+                     debug=True)
+    wait_request_is_finished(kivy_clock, req)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)
+
+
+@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
+def test_auth_header(kivy_clock):
+    from kivy.network.urlrequest import UrlRequest
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    head = {
+        "Authorization": "Basic {}".format(b64encode(
+            "{}:{}".format('user', 'passwd').encode('utf-8')
+        ).decode('utf-8'))
+    }
+    req = UrlRequest(
+        'http://httpbin.org/basic-auth/user/passwd',
+        on_success=obj._on_success,
+        on_progress=obj._on_progress,
+        on_error=obj._on_error,
+        on_redirect=obj._on_redirect,
+        req_headers=head,
+        debug=True
+    )
+    wait_request_is_finished(kivy_clock, req)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)
+    assert queue[-1][2] == ({'authenticated': True, 'user': 'user'}, )
+
+
+@pytest.mark.skipif(os.environ.get('NONETWORK'), reason="No network")
+def test_auth_auto(kivy_clock):
+    from kivy.network.urlrequest import UrlRequest
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    req = UrlRequest(
+        'http://user:passwd@httpbin.org/basic-auth/user/passwd',
+        on_success=obj._on_success,
+        on_progress=obj._on_progress,
+        on_error=obj._on_error,
+        on_redirect=obj._on_redirect,
+        debug=True
+    )
+    wait_request_is_finished(kivy_clock, req)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)
+    assert queue[-1][2] == ({'authenticated': True, 'user': 'user'}, )
+
+
+@pytest.mark.skipif(os.environ.get('nonetwork'), reason="no network")
+@pytest.mark.parametrize("scheme", ("http", "https"))
+def test_ca_file(kivy_clock, scheme):
+    """Passing a `ca_file` should not crash on http scheme, refs #6946"""
+    from kivy.network.urlrequest import UrlRequest
+    import certifi
+    obj = UrlRequestQueue([])
+    queue = obj.queue
+    req = UrlRequest(
+        f"{scheme}://httpbin.org/get",
+        on_success=obj._on_success,
+        on_progress=obj._on_progress,
+        on_error=obj._on_error,
+        on_redirect=obj._on_redirect,
+        ca_file=certifi.where(),
+        debug=True
+    )
+    wait_request_is_finished(kivy_clock, req)
+
+    if req.error and req.error.errno == 11001:
+        pytest.skip('Cannot connect to get address')
+
+    ensure_called_from_thread(queue)
+    check_queue_values(queue)
diff --git a/kivy/tests/test_utils.py b/kivy/tests/test_utils.py
new file mode 100644
index 0000000..7e3e9ed
--- /dev/null
+++ b/kivy/tests/test_utils.py
@@ -0,0 +1,240 @@
+'''
+utils tests
+===========
+'''
+
+import os
+import unittest
+try:
+    from unittest.mock import patch   # python 3.x
+except:
+    from mock import patch   # python 2.x
+
+from kivy.utils import (boundary, escape_markup, format_bytes_to_human,
+        is_color_transparent, SafeList, get_random_color, get_hex_from_color,
+        get_color_from_hex, strtotuple, QueryDict, intersection, difference,
+        interpolate, _get_platform, deprecated, reify)
+from kivy import utils
+
+
+class UtilsTest(unittest.TestCase):
+
+    def test_escape_markup(self):
+        escaped = escape_markup('Sun [1] & Moon [2].')
+        self.assertEqual(escaped, 'Sun &bl;1&br; &amp; Moon &bl;2&br;.')
+
+    def test_format_bytes_to_human(self):
+        a = format_bytes_to_human(6463)
+        self.assertEqual(a, '6.31 KB')
+        b = format_bytes_to_human(6463, precision=4)
+        self.assertEqual(b, '6.3115 KB')
+        c = format_bytes_to_human(646368746541)
+        self.assertEqual(c, '601.98 GB')
+
+    def test_boundary(self):
+        x = boundary(-1000, 0, 100)
+        self.assertEqual(x, 0)
+        x = boundary(1000, 0, 100)
+        self.assertEqual(x, 100)
+        x = boundary(50, 0, 100)
+        self.assertEqual(x, 50)
+
+    def test_is_color_transparent(self):
+        c = [1, 1, 1]
+        self.assertFalse(is_color_transparent(c))
+        c = [1, 1, 1, 1]
+        self.assertFalse(is_color_transparent(c))
+        c = [1, 1, 1, 0]
+        self.assertTrue(is_color_transparent(c))
+
+    @deprecated
+    def a_deprecated_function(self):
+        """ This one has doc string. """
+        pass
+
+    def test_deprecated(self):
+        self.a_deprecated_function()
+
+    def test_SafeList_iterate(self):  # deprecated
+        sl = SafeList(['1', 2, 3.])
+        self.assertTrue(isinstance(sl, list))
+        it = sl.iterate()
+        self.assertEqual(next(it), '1')
+        self.assertEqual(next(it), 2)
+        self.assertEqual(next(it), 3.)
+
+    def test_SafeList_iterate_reverse(self):  # deprecated
+        sl = SafeList(['1', 2, 3.])
+        self.assertTrue(isinstance(sl, list))
+        it = sl.iterate(reverse=True)
+        self.assertEqual(next(it), 3.)
+        self.assertEqual(next(it), 2)
+        self.assertEqual(next(it), '1')
+
+    def test_SafeList_clear(self):
+        sl = SafeList(['1', 2, 3.])
+        self.assertTrue(isinstance(sl, list))
+        sl.clear()
+        self.assertEqual(len(sl), 0)
+
+    def test_get_random_color_fixed_alpha(self):
+        actual = get_random_color()
+        self.assertEqual(len(actual), 4)
+        self.assertEqual(actual[3], 1.)
+
+        actual = get_random_color(alpha=.5)
+        self.assertEqual(len(actual), 4)
+        self.assertEqual(actual[3], .5)
+
+    def test_get_random_color_random_alpha(self):
+        actual = get_random_color(alpha='random')
+        self.assertEqual(len(actual), 4)
+
+    def test_get_hex_from_color_noalpha(self):
+        actual = get_hex_from_color([0, 1, 0])
+        expected = '#00ff00'
+        self.assertEqual(actual, expected)
+
+    def test_get_hex_from_color_alpha(self):
+        actual = get_hex_from_color([.25, .77, .90, .5])
+        expected = '#3fc4e57f'
+        self.assertEqual(actual, expected)
+
+    def test_get_color_from_hex_noalpha(self):
+        actual = get_color_from_hex('#d1a9c4')
+        expected = [0.81960784, 0.66274509, 0.76862745, 1.]
+        for i in range(4):
+            self.assertAlmostEqual(actual[i], expected[i])
+
+    def test_get_color_from_hex_alpha(self):
+        actual = get_color_from_hex('#00FF7F7F')
+        expected = [0., 1., 0.49803921, 0.49803921]  # can't get .5 from hex
+        for i in range(4):
+            self.assertAlmostEqual(actual[i], expected[i])
+
+    def test_strtotuple(self):
+        self.assertRaises(Exception, strtotuple, 'adis!_m%*+-=|')
+        self.assertRaises(Exception, strtotuple, '((12, 8, 473)')
+        self.assertRaises(Exception, strtotuple, '[12, 8, 473]]')
+        self.assertRaises(Exception, strtotuple, '128473')
+        actual = strtotuple('(12, 8, 473)')
+        expected = (12, 8, 473)
+        self.assertEqual(actual, expected)
+
+    def test_QueryDict(self):
+        qd = QueryDict()
+        self.assertTrue(isinstance(qd, dict))
+        # __setattr__
+        qd.toto = 1
+        self.assertEqual(qd.get('toto'), 1)
+        # __getattr__
+        toto = qd.toto
+        self.assertEqual(toto, 1)
+        with self.assertRaises(AttributeError):
+            foo = qd.not_an_attribute
+
+    def test_intersection(self):
+        abcd = ['a', 'b', 'c', 'd']
+        efgh = ['e', 'f', 'g', 'h']
+        fedc = ['c', 'd', 'e', 'f']  # cdef is cython keyword O_o)
+        feed = ['f', 'e', 'e', 'd']
+        self.assertEqual(intersection(abcd, efgh), [])
+        self.assertEqual(intersection(abcd, fedc), ['c', 'd'])
+        self.assertEqual(intersection(feed, feed), feed)
+        self.assertEqual(intersection([], []), [])
+        self.assertEqual(intersection(feed, fedc), feed)
+        self.assertEqual(intersection(fedc, feed), ['d', 'e', 'f'])
+        self.assertEqual(intersection(feed, efgh), ['f', 'e', 'e'])
+
+    def test_difference(self):
+        abcd = ['a', 'b', 'c', 'd']
+        efgh = ['e', 'f', 'g', 'h']
+        fedc = ['c', 'd', 'e', 'f']  # cdef is cython keyword O_o
+        feed = ['f', 'e', 'e', 'd']
+        self.assertEqual(difference(abcd, efgh), ['a', 'b', 'c', 'd'])
+        self.assertEqual(difference(efgh, fedc), ['g', 'h'])
+        self.assertEqual(difference([], []), [])
+        self.assertEqual(difference(abcd, abcd), [])
+        self.assertEqual(difference(fedc, feed), ['c'])
+        self.assertEqual(difference(feed, abcd), ['f', 'e', 'e'])
+        self.assertEqual(difference(abcd, feed), ['a', 'b', 'c'])
+
+    def test_interpolate_solo(self):
+        values = [10., 19., 27.1]
+        a = 0.
+        for i in range(0, 3):
+            a = interpolate(a, 100)
+            self.assertEqual(a, values[i])
+
+    def test_interpolate_multi(self):
+        x = [10., 19., 27.1]
+        y = [-10., -19., -27.1]
+        p = 0., 0.
+        for i in range(0, 3):
+            p = interpolate(p, [100, -100])
+            self.assertEqual(p, [x[i], y[i]])
+
+    @reify
+    def fib_100(self):
+        """ return 100th Fibonacci number
+        This uses modern view of F sub 1 = 0, F sub 2 = 1. """
+        # print("calculating...")
+        a, b = 0, 1
+        for n in range(2, 101):
+            a, b = b, a + b
+        return b
+
+    def test_reify(self):
+        # slow. self.fib_100 is a reify object making the lazy call.
+        first = self.fib_100
+        second = self.fib_100  # fast, self.fib_100 is a long.
+        assert first == second
+
+    def test_Platform_android(self):
+        with patch.dict('os.environ', {'KIVY_BUILD': 'android'}):
+            self.assertEqual(_get_platform(), 'android')
+        self.assertNotIn('KIVY_BUILD', os.environ)
+
+    def test_Platform_android_with_p4a(self):
+        with patch.dict('os.environ', {'P4A_BOOTSTRAP': 'sdl2'}):
+            self.assertEqual(_get_platform(), 'android')
+        self.assertNotIn('P4A_BOOTSTRAP', os.environ)
+
+    def test_Platform_android_with_android_argument(self):
+        with patch.dict('os.environ', {'ANDROID_ARGUMENT': ''}):
+            self.assertEqual(_get_platform(), 'android')
+        self.assertNotIn('ANDROID_ARGUMENT', os.environ)
+
+    def test_Platform_ios(self):
+        with patch.dict('os.environ', {'KIVY_BUILD': 'ios'}):
+            pf = _get_platform()
+            self.assertEqual(pf, 'ios')
+        self.assertNotIn('KIVY_BUILD', os.environ)
+
+    def test_Platform_win32(self):
+        self._test_platforms('win32', 'win')
+
+    def test_Platform_cygwin(self):
+        self._test_platforms('cygwin', 'win')
+
+    def test_Platform_linux2(self):
+        self._test_platforms('linux2', 'linux')
+
+    def test_Platform_darwin(self):
+        self._test_platforms('darwin', 'macosx')
+
+    def test_Platform_freebsd(self):
+        self._test_platforms('freebsd', 'linux')
+
+    def test_Platform_unknown(self):
+        self._test_platforms('randomdata', 'unknown')
+
+    def _test_platforms(self, input, testval):
+        utils._sys_platform = input
+        pf = _get_platform()
+        self.assertTrue(pf == testval)
+        # with patch('kivy.utils._sys_platform') as m:
+        #     m.__str__.return_value = input
+        #     m.__eq__ = lambda x, y: str(x) == y
+        #     pf = _get_platform()
+        #     self.assertTrue(str(pf) == testval)
diff --git a/kivy/tests/test_vector.py b/kivy/tests/test_vector.py
new file mode 100644
index 0000000..6645873
--- /dev/null
+++ b/kivy/tests/test_vector.py
@@ -0,0 +1,256 @@
+import unittest
+
+from kivy.vector import Vector
+from operator import truediv
+
+
+class VectorTestCase(unittest.TestCase):
+    def test_initializer_oneparameter_as_list(self):
+        vector = Vector([1])
+        self.assertEqual(vector.x, 1)
+        with self.assertRaises(IndexError):
+            vector.y
+
+    def test_initializer_oneparameter_as_int(self):
+        with self.assertRaises(TypeError):
+            Vector(1)
+
+    def test_initializer_twoparameters(self):
+        vector = Vector(1, 2)
+        self.assertEqual(vector.x, 1)
+        self.assertEqual(vector.y, 2)
+
+    def test_initializer_noparameter(self):
+        with self.assertRaises(Exception):
+            Vector()
+
+    def test_initializer_threeparameters(self):
+        with self.assertRaises(Exception):
+            Vector(1, 2, 3)
+
+    def test_sum_twovectors(self):
+        finalVector = Vector(1, 1) + Vector(1, 1)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_inplace(self):
+        finalVector = Vector(1, 1)
+        finalVector += Vector(1, 1)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_inplace_scalar(self):
+        finalVector = Vector(1, 1)
+        finalVector += 1
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_scalar(self):
+        with self.assertRaises(TypeError):
+            Vector(1, 1) + 1
+
+    def test_sub_twovectors(self):
+        finalVector = Vector(3, 3) - Vector(2, 2)
+        self.assertEqual(finalVector.x, 1)
+        self.assertEqual(finalVector.y, 1)
+
+    def test_sub_inplace(self):
+        finalVector = Vector(3, 3)
+        finalVector -= Vector(2, 2)
+        self.assertEqual(finalVector.x, 1)
+        self.assertEqual(finalVector.y, 1)
+
+    def test_sub_scalar(self):
+        with self.assertRaises(TypeError):
+            Vector(3, 3) - 2
+
+    def test_sub_inplace_scalar(self):
+        finalVector = Vector(3, 3)
+        finalVector -= 2
+        self.assertEqual(finalVector.x, 1)
+        self.assertEqual(finalVector.y, 1)
+
+    def test_mul_twovectors(self):
+        finalVector = Vector(2, 2) * Vector(3, 3)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_mul_inplace(self):
+        finalVector = Vector(2, 2)
+        finalVector *= Vector(3, 3)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_mul_inplace_scalar(self):
+        finalVector = Vector(2, 2)
+        finalVector *= 3
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_mul_scalar(self):
+        finalVector = Vector(2, 2) * 3
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_rmul_list(self):
+        finalVector = (3, 3) * Vector(2, 2)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_rmul_scalar(self):
+        finalVector = 3 * Vector(2, 2)
+        self.assertEqual(finalVector.x, 6)
+        self.assertEqual(finalVector.y, 6)
+
+    def test_div_twovectors(self):
+        finalVector = Vector(6, 6) / Vector(2, 2)
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_truediv_twovectors(self):
+        finalVector = truediv(Vector(6, 6), Vector(2., 2.))
+        self.assertAlmostEqual(finalVector.x, 3.)
+        self.assertAlmostEqual(finalVector.y, 3.)
+
+    def test_truediv_scalar(self):
+        finalVector = truediv(Vector(6, 6), 2.)
+        self.assertAlmostEqual(finalVector.x, 3.)
+        self.assertAlmostEqual(finalVector.y, 3.)
+
+    def test_div_inplace(self):
+        finalVector = Vector(6, 6)
+        finalVector /= Vector(2, 2)
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_div_inplace_scalar(self):
+        finalVector = Vector(6, 6)
+        finalVector /= 2
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_div_scalar(self):
+        finalVector = Vector(6, 6) / 2
+        self.assertEqual(finalVector.x, 3)
+        self.assertEqual(finalVector.y, 3)
+
+    def test_rdiv_list(self):
+        finalVector = (6.0, 6.0) / Vector(3.0, 3.0)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_rdiv_scalar(self):
+        finalVector = 6 / Vector(3, 3)
+        self.assertEqual(finalVector.x, 2)
+        self.assertEqual(finalVector.y, 2)
+
+    def test_sum_oversizedlist(self):
+        Vector(6, 6) + (1, 2)
+
+    def test_negation(self):
+        vector = - Vector(1, 1)
+        self.assertEqual(vector.x, -1)
+        self.assertEqual(vector.y, -1)
+
+    def test_length(self):
+        length = Vector(10, 10).length()
+        self.assertEqual(length, 14.142135623730951)
+
+    def test_length_zerozero(self):
+        length = Vector(0, 0).length()
+        self.assertEqual(length, 0)
+
+    def test_length2(self):
+        length = Vector(10, 10).length2()
+        self.assertEqual(length, 200)
+
+    def test_distance(self):
+        distance = Vector(10, 10).distance((5, 10))
+        self.assertEqual(distance, 5)
+
+    def test_distance2(self):
+        distance = Vector(10, 10).distance2((5, 10))
+        self.assertEqual(distance, 25)
+
+    def test_normalize(self):
+        vector = Vector(88, 33).normalize()
+        self.assertAlmostEqual(vector.x, 0.93632917756904444)
+        self.assertAlmostEqual(vector.y, 0.3511234415883917)
+        self.assertAlmostEqual(vector.length(), 1.0)
+
+    def test_normalize_zerovector(self):
+        vector = Vector(0, 0).normalize()
+        self.assertEqual(vector.x, 0)
+        self.assertEqual(vector.y, 0)
+        self.assertEqual(vector.length(), 0)
+
+    def test_dot(self):
+        result = Vector(2, 4).dot((2, 2))
+        self.assertEqual(result, 12)
+
+    def test_angle(self):
+        result = Vector(100, 0).angle((0, 100))
+        self.assertAlmostEqual(result, -90.0)
+
+    def test_rotate(self):
+        v = Vector(100, 0)
+        v = v.rotate(45)
+        self.assertAlmostEqual(v.x, 70.710678118654755)
+        self.assertAlmostEqual(v.y, 70.710678118654741)
+
+    def test_(self):
+        a = (98, 28)
+        b = (72, 33)
+        c = (10, -5)
+        d = (20, 88)
+        result = Vector.line_intersection(a, b, c, d)
+        self.assertAlmostEqual(result.x, 15.25931928687196)
+        self.assertAlmostEqual(result.y, 43.911669367909241)
+
+    def test_inbbox(self):
+        bmin = (0, 0)
+        bmax = (100, 100)
+        result = Vector.in_bbox((50, 50), bmin, bmax)
+        self.assertTrue(result)
+        result = Vector.in_bbox((647, -10), bmin, bmax)
+        self.assertFalse(result)
+
+    def test_intersection_roundingerror(self):
+        # ref #2983, #5568
+
+        v1 = (25.0, 200.0)
+        v2 = (25.0, 400.0)
+        v3 = (36.75, 300.0)
+        result = [25.0, 300.0]
+
+        def almost(a, b):
+            # 300.0 sometimes is 299.9.. or 300.1.. however
+            # we just want to know that it's really close
+            self.assertIsNotNone(a)
+            self.assertIsNotNone(b)
+            self.assertAlmostEqual(a[0], b[0], places=0)
+            self.assertAlmostEqual(a[1], b[1], places=0)
+
+        for i in range(1, 100):
+            st = "6.4" + "9" * i
+            v = (float(st), 300.0)
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+        for i in range(1, 100):
+            st = "6.1" + "1" * i
+            v = (float(st), 300.0)
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+        for i in range(1, 100):
+            st = "6.4" + "4" * i
+            v = (float(st), 300.0)
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+        for i in range(1, 100):
+            st = "300.4" + "9" * i
+            v = (6.5, float(st))
+            almost(result, Vector.segment_intersection(v1, v2, v3, v))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/kivy/tests/test_video.py b/kivy/tests/test_video.py
new file mode 100644
index 0000000..0dde575
--- /dev/null
+++ b/kivy/tests/test_video.py
@@ -0,0 +1,25 @@
+
+import unittest
+
+
+class VideoTestCase(unittest.TestCase):
+
+    def test_video_unload(self):
+        # fix issue https://github.com/kivy/kivy/issues/2275
+        # AttributeError: 'NoneType' object has no attribute 'texture'
+        from kivy.uix.video import Video
+        from kivy.clock import Clock
+        from kivy.base import runTouchApp, stopTouchApp
+        from kivy import kivy_examples_dir
+        from os.path import join, dirname, abspath
+        source = abspath(join(kivy_examples_dir, "widgets", "cityCC0.mpg"))
+        video = Video(source=source, play=True)
+        Clock.schedule_once(lambda x: stopTouchApp(), 1)
+
+        def unload_video(video, position):
+            if position > 0.01:
+                video.unload()
+                Clock.schedule_once(lambda x: stopTouchApp(), 0.1)
+
+        video.bind(position=unload_video)
+        runTouchApp(video)
diff --git a/kivy/tests/test_weakmethod.py b/kivy/tests/test_weakmethod.py
new file mode 100644
index 0000000..10a0f05
--- /dev/null
+++ b/kivy/tests/test_weakmethod.py
@@ -0,0 +1,44 @@
+import gc
+
+
+def test_weak_method_on_obj():
+    from kivy.weakmethod import WeakMethod
+
+    class SomeClass:
+
+        def do_something(self):
+            pass
+
+    obj = SomeClass()
+    weak_method = WeakMethod(obj.do_something)
+
+    assert not weak_method.is_dead()
+    assert weak_method() == obj.do_something
+    assert weak_method == WeakMethod(obj.do_something)
+    assert weak_method != WeakMethod(SomeClass().do_something)
+
+    del obj
+    gc.collect()
+
+    assert weak_method.is_dead()
+    assert weak_method() is None
+    assert weak_method != WeakMethod(SomeClass().do_something)
+
+
+def test_weak_method_func():
+    from kivy.weakmethod import WeakMethod
+
+    def do_something():
+        pass
+
+    weak_method = WeakMethod(do_something)
+
+    assert not weak_method.is_dead()
+    assert weak_method() == do_something
+    assert weak_method == WeakMethod(do_something)
+
+    del do_something
+    gc.collect()
+
+    assert not weak_method.is_dead()
+    assert weak_method() is not None
diff --git a/kivy/tests/test_widget.py b/kivy/tests/test_widget.py
new file mode 100644
index 0000000..f710260
--- /dev/null
+++ b/kivy/tests/test_widget.py
@@ -0,0 +1,127 @@
+import unittest
+from tempfile import mkdtemp
+from shutil import rmtree
+
+
+class WidgetTestCase(unittest.TestCase):
+
+    def setUp(self):
+        from kivy.uix.widget import Widget
+        self.cls = Widget
+        self.root = Widget()
+
+    def test_add_remove_widget(self):
+        root = self.root
+        self.assertEqual(root.children, [])
+        c1 = self.cls()
+        root.add_widget(c1)
+        self.assertEqual(root.children, [c1])
+        root.remove_widget(c1)
+        self.assertEqual(root.children, [])
+
+    def test_invalid_add_widget(self):
+        from kivy.uix.widget import WidgetException
+        try:
+            # None of them should work
+            self.root.add_widget(None)
+            self.root.add_widget(WidgetException)
+            self.root.add_widget(self.cls)
+            self.fail()
+        except WidgetException:
+            pass
+
+    def test_clear_widgets(self):
+        root = self.root
+        self.assertEqual(root.children, [])
+
+        c1 = self.cls()
+        c2 = self.cls()
+        c3 = self.cls()
+        root.add_widget(c1, index=0)
+        root.add_widget(c2, index=1)
+        root.add_widget(c3, index=2)
+        self.assertEqual(root.children, [c1, c2, c3])
+
+        root.clear_widgets([c2])
+        self.assertEqual(root.children, [c1, c3])
+
+        root.clear_widgets([])
+        self.assertEqual(root.children, [c1, c3])
+
+        root.clear_widgets()
+        self.assertEqual(root.children, [])
+
+    def test_clear_widgets_children(self):
+        root = self.root
+        for _ in range(10):
+            root.add_widget(self.cls())
+        self.assertEqual(len(root.children), 10)
+
+        root.clear_widgets(root.children)
+        self.assertEqual(root.children, [])
+
+    def test_position(self):
+        wid = self.root
+        wid.x = 50
+        self.assertEqual(wid.x, 50)
+        self.assertEqual(wid.pos, [50, 0])
+        wid.y = 60
+        self.assertEqual(wid.y, 60)
+        self.assertEqual(wid.pos, [50, 60])
+        wid.pos = (0, 0)
+        self.assertEqual(wid.pos, [0, 0])
+        self.assertEqual(wid.x, 0)
+        self.assertEqual(wid.y, 0)
+
+    def test_size(self):
+        wid = self.root
+        wid.width = 50
+        self.assertEqual(wid.width, 50)
+        self.assertEqual(wid.size, [50, 100])
+        wid.height = 60
+        self.assertEqual(wid.height, 60)
+        self.assertEqual(wid.size, [50, 60])
+        wid.size = (100, 100)
+        self.assertEqual(wid.size, [100, 100])
+        self.assertEqual(wid.width, 100)
+        self.assertEqual(wid.height, 100)
+
+    def test_collision(self):
+        wid = self.root
+        self.assertEqual(wid.pos, [0, 0])
+        self.assertEqual(wid.size, [100, 100])
+        self.assertEqual(wid.collide_point(-1, -1), False)
+        self.assertEqual(wid.collide_point(0, 0), True)
+        self.assertEqual(wid.collide_point(50, 50), True)
+        self.assertEqual(wid.collide_point(100, 100), True)
+        self.assertEqual(wid.collide_point(200, 0), False)
+        self.assertEqual(wid.collide_point(500, 500), False)
+
+    # Currently rejected with a Shader didn't link, but work alone.
+    @unittest.skip("Doesn't work with testsuite, but work alone")
+    def test_export_to_png(self):
+        from kivy.core.image import Image as CoreImage
+        from kivy.uix.button import Button
+        from os.path import join
+
+        wid = Button(text='test', size=(200, 100), size_hint=(None, None))
+        self.root.add_widget(wid)
+
+        tmp = mkdtemp()
+        wid.export_to_png(join(tmp, 'a.png'))
+        wid.export_to_png(join(tmp, 'b.png'), scale=.5)
+        wid.export_to_png(join(tmp, 'c.png'), scale=2)
+
+        self.assertEqual(CoreImage(join(tmp, 'a.png')).size, (200, 100))
+        self.assertEqual(CoreImage(join(tmp, 'b.png')).size, (100, 50))
+        self.assertEqual(CoreImage(join(tmp, 'c.png')).size, (400, 200))
+        rmtree(tmp)
+
+        self.root.remove_widget(wid)
+
+    def test_disabled(self):
+        from kivy.uix.widget import Widget
+        w = Widget(disabled=None)
+        w.disabled = False
+        w.disabled = True
+        self.assertEqual(w.disabled, True)
diff --git a/kivy/tests/test_widget_walk.py b/kivy/tests/test_widget_walk.py
new file mode 100644
index 0000000..72d8d6f
--- /dev/null
+++ b/kivy/tests/test_widget_walk.py
@@ -0,0 +1,70 @@
+import unittest
+
+
+class FileWidgetWalk(unittest.TestCase):
+
+    def test_walk_large_tree(self):
+        from kivy.uix.boxlayout import BoxLayout
+        from kivy.uix.label import Label
+        ''' the tree
+        BoxLayout
+            BoxLayout
+            Label
+                10 labels
+            BoxLayout
+                10 labels
+            BoxLayout
+                Label
+            Label
+        '''
+
+        root = BoxLayout()
+        tree = [root]
+
+        box = BoxLayout()
+        tree.append(box)
+        root.add_widget(box)
+
+        label = Label()
+        tree.append(label)
+        root.add_widget(label)
+        for i in range(10):
+            tree.append(Label())
+            label.add_widget(tree[-1])
+
+        box = BoxLayout()
+        tree.append(box)
+        root.add_widget(box)
+        for i in range(10):
+            tree.append(Label())
+            box.add_widget(tree[-1])
+
+        box = BoxLayout()
+        tree.append(box)
+        root.add_widget(box)
+        tree.append(Label())
+        box.add_widget(tree[-1])
+
+        label = Label()
+        tree.append(label)
+        root.add_widget(label)
+
+        def rotate(l, n):
+            return l[n:] + l[:n]
+
+        for i in range(len(tree)):
+            rotated = rotate(tree, i)   # shift list to start at i
+            # walk starting with i
+            walked = [n for n in tree[i].walk(loopback=True)]
+            walked_reversed = [n for n in tree[i].walk_reverse(loopback=True)]
+
+            self.assertListEqual(rotated, walked)
+            self.assertListEqual(walked, list(reversed(walked_reversed)))
+
+    def test_walk_single(self):
+        from kivy.uix.label import Label
+
+        label = Label()
+        self.assertListEqual([n for n in label.walk(loopback=True)], [label])
+        self.assertListEqual([n for n in label.walk_reverse(loopback=True)],
+                             [label])
diff --git a/kivy/tests/test_window_base.py b/kivy/tests/test_window_base.py
new file mode 100644
index 0000000..d99ebdc
--- /dev/null
+++ b/kivy/tests/test_window_base.py
@@ -0,0 +1,20 @@
+from itertools import product
+
+from kivy.tests import GraphicUnitTest
+
+
+class WindowBaseTest(GraphicUnitTest):
+
+    def test_to_normalized_pos(self):
+        win = self.Window
+        old_system_size = win.system_size[:]
+        win.system_size = w, h = type(old_system_size)((320, 240))
+        try:
+            for x, y in product([0, 319, 50, 51], [0, 239, 50, 51]):
+                expected_sx = x / (w - 1.0)
+                expected_sy = y / (h - 1.0)
+                result_sx, result_sy = win.to_normalized_pos(x, y)
+                assert result_sx == expected_sx
+                assert result_sy == expected_sy
+        finally:
+            win.system_size = old_system_size
diff --git a/kivy/tests/test_window_info.py b/kivy/tests/test_window_info.py
new file mode 100644
index 0000000..8300da8
--- /dev/null
+++ b/kivy/tests/test_window_info.py
@@ -0,0 +1,29 @@
+from kivy.tests.common import GraphicUnitTest
+from kivy import setupconfig
+
+
+class WindowInfoTest(GraphicUnitTest):
+    def test_window_info_nonzero(self):
+        from kivy.core.window import Window
+        window_info = Window.get_window_info()
+        if window_info is None:
+            return
+
+        if setupconfig.USE_X11:
+            from kivy.core.window.window_info import WindowInfoX11
+            if isinstance(window_info, WindowInfoX11):
+                self.assertNotEqual(window_info.display, 0)
+                self.assertNotEqual(window_info.window, 0)
+
+        if setupconfig.USE_WAYLAND:
+            from kivy.core.window.window_info import WindowInfoWayland
+            if isinstance(window_info, WindowInfoWayland):
+                self.assertNotEqual(window_info.display, 0)
+                self.assertNotEqual(window_info.surface, 0)
+                self.assertNotEqual(window_info.shell_surface, 0)
+
+        if setupconfig.PLATFORM == 'win32':
+            from kivy.core.window.window_info import WindowInfoWindows
+            if isinstance(window_info, WindowInfoWindows):
+                self.assertNotEqual(window_info.window, 0)
+                self.assertNotEqual(window_info.hdc, 0)
diff --git a/kivy/tests/testkv.kv b/kivy/tests/testkv.kv
new file mode 100644
index 0000000..3a7733d
--- /dev/null
+++ b/kivy/tests/testkv.kv
@@ -0,0 +1 @@
+#:kivy 1.4.1
diff --git a/kivy/tests/unicode_files.zip b/kivy/tests/unicode_files.zip
new file mode 100644
index 0000000..0ab330f
Binary files /dev/null and b/kivy/tests/unicode_files.zip differ
diff --git a/kivy/tests/unicode_font.zip b/kivy/tests/unicode_font.zip
new file mode 100644
index 0000000..07b17fb
Binary files /dev/null and b/kivy/tests/unicode_font.zip differ
diff --git a/kivy/tests/visual_test_label.py b/kivy/tests/visual_test_label.py
new file mode 100644
index 0000000..15a930c
--- /dev/null
+++ b/kivy/tests/visual_test_label.py
@@ -0,0 +1,291 @@
+from kivy.app import runTouchApp
+from kivy.uix.gridlayout import GridLayout
+from kivy.properties import StringProperty
+from kivy.lang import Builder
+from kivy.utils import get_hex_from_color, get_random_color
+import timeit
+import re
+import random
+from functools import partial
+
+
+def layout_perf(label, repeat):
+    if repeat:
+        repeat = int(repeat)
+    else:
+        return 'None'
+    return str(timeit.Timer(label._label.render).repeat(1, repeat))
+
+
+def layout_real_perf(label, repeat):
+    if repeat:
+        repeat = int(repeat)
+    else:
+        return 'None'
+    old_text = label._label.texture
+    label._label.texture = label._label.texture_1px
+    res = str(timeit.Timer(partial(label._label.render, True)).repeat(1,
+                                                                      repeat))
+    label._label.texture = old_text
+    return res
+
+
+kv = '''
+#:import tlp visual_test_label.layout_perf
+#:import tlrp visual_test_label.layout_real_perf
+
+<TSliderButton@ToggleButton>:
+    size_hint: None, None
+    size: 100, 50
+    group: 'slider'
+    on_press: self.parent.slider.name = self.text if self.state =='down' else\
+    'dummy'
+
+<TSpinner@Spinner>:
+    size_hint: None, None
+    size: 100, 50
+    name: ''
+    on_text: setattr(self.parent.label, self.name, self.text)
+
+<TBoolButton@ToggleButton>:
+    size_hint: None, None
+    size: 100, 50
+    on_state: setattr(self.parent.label, self.text, self.state == 'down')
+
+<TLabel@Label>:
+    size_hint: None, None
+    size: 100, 50
+
+
+<LabelTest>:
+    cols: 1
+    spacing: 10
+    padding: 20
+    TabbedPanel:
+        do_default_tab: False
+        tab_width: self.width / 11 * 3
+        TabbedPanelItem:
+            text: 'Label'
+            BoxLayout:
+                ScrollView:
+                    id: scrollview
+                    Label:
+                        size_hint: None, None
+                        size: self.texture_size
+                        id: label
+                        text: record.text
+                        dummy: 0
+                        canvas:
+                            Color:
+                                rgba: 0, 1, 0, 0.5
+                            Rectangle:
+                                pos: self.pos
+                                size: self.width, self.padding_y
+                            Rectangle:
+                                pos: self.x, self.y + self.height -\
+                                self.padding_y
+                                size: self.width, self.padding_y
+                            Color:
+                                rgba: 0, 0, 1, 0.5
+                            Rectangle:
+                                pos: self.pos
+                                size: self.padding_x, self.height
+                            Rectangle:
+                                pos: self.x + self.width - self.padding_x,\
+                                self.y
+                                size: self.padding_x, self.height
+                Splitter:
+                    sizable_from: 'left'
+                    TextInput:
+                        id: record
+                        text: label.text
+                        text: root.text
+        TabbedPanelItem:
+            text: 'Test performance'
+            BoxLayout:
+                orientation: 'vertical'
+                Label:
+                    text: 'Test timeit performance with current label settings'
+                BoxLayout:
+                    size_hint_y: None
+                    height: 40
+                    padding: [20, 0]
+                    Label:
+                        text: 'Repeat count: '
+                    TextInput:
+                        id: repeat
+                        text: '1000'
+                    Button:
+                        text: 'Go (render - layout)'
+                        on_press: results.text = tlp(label, repeat.text)
+                    Button:
+                        text: 'Go (render_real)'
+                        on_press: results.text = tlrp(label, repeat.text)
+                Label:
+                    id: results
+                    text: 'Results:'
+
+    StackLayout:
+        id: slider_ctrl
+        size_hint_y: None
+        height: self.minimum_height
+        slider: slider
+        label: label
+        TLabel:
+            text: 'halign: '
+        TSpinner:
+            name: 'halign'
+            values: ['left', 'center', 'right', 'justify']
+            text: 'left'
+        TLabel:
+            text: 'valign: '
+        TSpinner:
+            name: 'valign'
+            values: ['top', 'middle', 'center', 'bottom']
+            text: 'bottom'
+        TBoolButton:
+            text: 'markup'
+        TBoolButton:
+            text: 'shorten'
+        TextInput:
+            size_hint: None, None
+            size: 100, 50
+            hint_text: 'split_str'
+            on_text_validate: label.split_str = self.text
+            multiline: False
+        TLabel:
+            text: 'shorten_from: '
+        TSpinner:
+            name: 'shorten_from'
+            values: ['left', 'center', 'right']
+            text: 'right'
+        TBoolButton:
+            text: 'strip'
+            state: 'down'
+        ToggleButton:
+            size_hint: None, None
+            size: 100, 50
+            text: 'random size'
+            on_state: label.text = root.sized_text if self.state == 'down'\
+            else root.text
+        TLabel:
+            text: 'Slider control:'
+        TSliderButton:
+            text: 'font_size'
+        TSliderButton:
+            text: 'line_height'
+        TSliderButton:
+            text: 'max_lines'
+        TSliderButton:
+            text: 'padding_x'
+        TSliderButton:
+            text: 'padding_y'
+        TextInput:
+            size_hint: None, None
+            size: 100, 50
+            hint_text: 'text_size[0]'
+            on_text_validate: label.text_size = (int(self.text) if self.text\
+            else None), label.text_size[1]
+            multiline: False
+        TextInput:
+            size_hint: None, None
+            size: 100, 50
+            hint_text: 'text_size[1]'
+            on_text_validate: label.text_size = label.text_size[0],\
+            (int(self.text) if self.text else None)
+            multiline: False
+        TLabel:
+            text: '<-- w/ validate'
+    Label:
+        size_hint_y: None
+        height: 40
+        color: [0, 1, 0, 1]
+        text_size: self.size
+        text: 'scrollview size: {}, label size: {}, text_size: {}, '\
+        'texture_size: {}, padding: {}'.format(scrollview.size, label.size,\
+        label.text_size, label.texture_size, label.padding)
+
+    BoxLayout:
+        size_hint_y: None
+        height: 40
+        Slider:
+            id: slider
+            range: -10, 200
+            value: 15
+            name: 'dummy'
+            on_value: setattr(label, self.name, self.value)
+        Label:
+            size_hint_x: None
+            width: 50
+            text: str(int(slider.value))
+
+'''
+
+
+text = '''
+Because it would spare your Majesty all fear of future \
+annoyance. If the lady loves her husband, she does not love your \
+Majesty. If she does not love your Majesty, there is no reason \
+why she should interfere with your Majesty's plan.
+
+"It is true. And yet--Well! I wish she had been of my own \
+station! What a queen she would have made!" He relapsed into a \
+moody silence, which was not broken until we drew up in \
+Serpentine Avenue.
+
+The door of Briony Lodge was open, and an elderly woman stood \
+upon the steps. She watched us with a sardonic eye as we stepped \
+from the brougham.
+
+Mr. Sherlock Holmes, I believe?" said she.
+
+I am Mr. Holmes," answered my companion, looking at her with a \
+questioning and rather startled gaze.
+
+Indeed! My mistress told me that you were likely to call. She \
+left this morning with her husband by the 5:15 train from Charing \
+Cross for the Continent."
+
+"What!" Sherlock Holmes staggered back, white with chagrin and \
+surprise. "Do you mean that she has left England?"
+
+Never to return.
+
+"And the papers?" asked the King hoarsely. "All is lost."
+'''
+
+words = re.split('( +|\\n+)', text)
+
+
+def annotate(pre, post, callable, words):
+    state = False
+    i = random.randint(0, 4)
+    while i < len(words):
+        if ' ' in words[i] or '\n' in words[i]:  # skip spaces
+            i += 1
+            continue
+        if not state:
+            words[i] = pre.format(callable(), words[i])
+        else:
+            words[i] = post.format(words[i])
+        state = not state
+        i += random.randint(1, 7)
+
+
+annotate('[size={0}]{1}', '{0}[/size]', partial(random.randint, 8, 24), words)
+annotate('[b]{1}', '{0}[/b]', str, words)
+annotate('[i]{1}', '{0}[/i]', str, words)
+annotate('[color={0}]{1}', '{0}[/color]',
+         lambda: get_hex_from_color(get_random_color()), words)
+annotated_text = ''.join(words)
+
+
+class LabelTest(GridLayout):
+
+    text = StringProperty(text)
+    sized_text = StringProperty(annotated_text)
+
+
+if __name__ in ('__main__', ):
+    Builder.load_string(kv)
+    runTouchApp(LabelTest())
diff --git a/kivy/tools/__init__.py b/kivy/tools/__init__.py
new file mode 100644
index 0000000..cdb3e81
--- /dev/null
+++ b/kivy/tools/__init__.py
@@ -0,0 +1,44 @@
+"""
+Tools
+=====
+
+The tools module provides various utility scripts, modules and examples.
+
+Scripts
+-------
+
+Some useful scripts include:
+
+* :file:`kviewer.py`: for viewing kv files with automatic updating
+* :file:`benchmark.py`: provides detailed OpenGL hardware information as well
+  as some benchmarks measuring kivy specific performance
+* :file:`reports.py`: provides a comprehensive report covering your systems
+  providers, libraries, configuration, environment, input devices and options
+* :file:`texturecompress.py`: a command line utility for compressing images
+  into PVRTC or ETC1 formats
+* :file:`generate-icons.py`: generates set of icons suitable for the various
+  store and package formats
+* :file:`gles_compat/subset_gles.py`: examines compatibility between GLEXT and
+  GLES2 headers for finding compatible subsets
+
+Modules
+-------
+
+Tool modules provide various resources for:
+
+* :mod:`~kivy.tools.packaging`
+* :mod:`text editor highlighting <kivy.tools.highlight>`
+
+
+Other
+-----
+
+Other miscellaneous resources include
+
+* :file:`pep8checker`: pep8 checking scripts and git hook
+* :file:`theming`: demonstrates an alternative theme for kivy
+* :file:`travis`: travis continuous integration
+
+This help document is a work-in-progress and currently under construction.
+
+"""
diff --git a/kivy/tools/__pycache__/__init__.cpython-310.pyc b/kivy/tools/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..66e9e6c
Binary files /dev/null and b/kivy/tools/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/benchmark.cpython-310.pyc b/kivy/tools/__pycache__/benchmark.cpython-310.pyc
new file mode 100644
index 0000000..d9de462
Binary files /dev/null and b/kivy/tools/__pycache__/benchmark.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/changelog_parser.cpython-310.pyc b/kivy/tools/__pycache__/changelog_parser.cpython-310.pyc
new file mode 100644
index 0000000..dad341b
Binary files /dev/null and b/kivy/tools/__pycache__/changelog_parser.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/coverage.cpython-310.pyc b/kivy/tools/__pycache__/coverage.cpython-310.pyc
new file mode 100644
index 0000000..a51064c
Binary files /dev/null and b/kivy/tools/__pycache__/coverage.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/gallery.cpython-310.pyc b/kivy/tools/__pycache__/gallery.cpython-310.pyc
new file mode 100644
index 0000000..22f808e
Binary files /dev/null and b/kivy/tools/__pycache__/gallery.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/generate-icons.cpython-310.pyc b/kivy/tools/__pycache__/generate-icons.cpython-310.pyc
new file mode 100644
index 0000000..f277bc0
Binary files /dev/null and b/kivy/tools/__pycache__/generate-icons.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/kviewer.cpython-310.pyc b/kivy/tools/__pycache__/kviewer.cpython-310.pyc
new file mode 100644
index 0000000..a87838a
Binary files /dev/null and b/kivy/tools/__pycache__/kviewer.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/report.cpython-310.pyc b/kivy/tools/__pycache__/report.cpython-310.pyc
new file mode 100644
index 0000000..f717ee0
Binary files /dev/null and b/kivy/tools/__pycache__/report.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/stub-gl-debug.cpython-310.pyc b/kivy/tools/__pycache__/stub-gl-debug.cpython-310.pyc
new file mode 100644
index 0000000..e4893a8
Binary files /dev/null and b/kivy/tools/__pycache__/stub-gl-debug.cpython-310.pyc differ
diff --git a/kivy/tools/__pycache__/texturecompress.cpython-310.pyc b/kivy/tools/__pycache__/texturecompress.cpython-310.pyc
new file mode 100644
index 0000000..9218ff9
Binary files /dev/null and b/kivy/tools/__pycache__/texturecompress.cpython-310.pyc differ
diff --git a/kivy/tools/benchmark.py b/kivy/tools/benchmark.py
new file mode 100644
index 0000000..772c45c
--- /dev/null
+++ b/kivy/tools/benchmark.py
@@ -0,0 +1,286 @@
+'''
+Benchmark
+=========
+
+This script performs and displays the results of a set of benchmarks. These
+provide a set of metrics mainly aimed at gauging the OpenGL performance of your
+system.
+
+It also provides more specs regarding your graphics card setup together with
+more comprehensive system information.
+'''
+
+from __future__ import print_function
+
+benchmark_version = '1'
+
+import os
+import sys
+import json
+import kivy
+import gc
+from time import clock, time, ctime
+from random import randint
+
+from kivy.uix.label import Label
+from kivy.uix.button import Button
+from kivy.uix.widget import Widget
+from kivy.graphics import RenderContext
+from kivy.input.motionevent import MotionEvent
+from kivy.cache import Cache
+from kivy.clock import Clock
+from kivy.compat import PY2
+
+if not PY2:
+    xrange = range
+
+clockfn = time
+if sys.platform == 'win32':
+    clockfn = clock
+
+
+class FakeMotionEvent(MotionEvent):
+    pass
+
+
+class bench_widget_creation:
+    '''Widget: creation (10000 Widget)'''
+
+    def run(self):
+        o = []
+        for x in range(10000):
+            o.append(Widget())
+
+
+class bench_widget_creation_with_root:
+    '''Widget: creation (10000 Widget + 1 root)'''
+
+    def run(self):
+        o = Widget()
+        for x in range(10000):
+            o.add_widget(Widget())
+
+
+class bench_widget_draw:
+    '''Widget: empty drawing (10000 Widget + 1 root)'''
+
+    def __init__(self):
+        self.ctx = RenderContext()
+        self.root = root = Widget()
+        for x in range(10000):
+            root.add_widget(Widget())
+        self.ctx.add(self.root.canvas)
+
+    def run(self):
+        self.ctx.draw()
+
+
+class bench_widget_dispatch:
+    '''Widget: event dispatch (1000 on_update in 10*1000 Widget)'''
+
+    def __init__(self):
+        root = Widget()
+        for x in range(10):
+            parent = Widget()
+            for y in range(1000):
+                parent.add_widget(Widget())
+            root.add_widget(parent)
+        self.root = root
+
+    def run(self):
+        touch = FakeMotionEvent('fake', 1, [])
+        self.root.dispatch('on_touch_down', touch)
+        self.root.dispatch('on_touch_move', touch)
+        self.root.dispatch('on_touch_up', touch)
+
+
+class bench_label_creation:
+    '''Core: label creation (10000 * 10 a-z)'''
+
+    def __init__(self):
+        labels = []
+        for x in range(10000):
+            label = [chr(randint(ord('a'), ord('z'))) for x in range(10)]
+            labels.append(''.join(label))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Label(text=x))
+
+
+class bench_button_creation:
+    '''Core: button creation (10000 * 10 a-z)'''
+
+    def __init__(self):
+        labels = []
+        for x in xrange(10000):
+            button = map(lambda x: chr(randint(ord('a'), ord('z'))),
+                         xrange(10))
+            labels.append(''.join(button))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Button(text=x))
+
+
+class bench_label_creation_with_tick:
+    '''Core: label creation (10000 * 10 a-z), with Clock.tick'''
+
+    def __init__(self):
+        labels = []
+        for x in range(10000):
+            label = [chr(randint(ord('a'), ord('z'))) for x in range(10)]
+            labels.append(''.join(label))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Label(text=x))
+        # tick for texture creation
+        Clock.tick()
+
+
+class bench_button_creation_with_tick:
+    '''Core: button creation (10000 * 10 a-z), with Clock.tick'''
+
+    def __init__(self):
+        labels = []
+        for x in xrange(10000):
+            button = map(lambda x: chr(randint(ord('a'), ord('z'))),
+                         xrange(10))
+            labels.append(''.join(button))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Button(text=x))
+        # tick for texture creation
+        Clock.tick()
+
+
+if __name__ == '__main__':
+
+    report = []
+    report_newline = True
+    Clock.start_clock()
+
+    def log(s, newline=True):
+        global report_newline
+        if not report_newline:
+            report[-1] = '%s %s' % (report[-1], s)
+        else:
+            report.append(s)
+        if newline:
+            print(s)
+            report_newline = True
+        else:
+            print(s, end=' ')
+            report_newline = False
+        sys.stdout.flush()
+
+    clock_total = 0
+    benchs = list(globals().keys())
+    benchs.sort()
+    benchs = [globals()[x] for x in benchs if x.startswith('bench_')]
+
+    log('')
+    log('=' * 70)
+    log('Kivy Benchmark v%s' % benchmark_version)
+    log('=' * 70)
+    log('')
+    log('System information')
+    log('-------------------')
+
+    log('OS platform     : %s' % sys.platform)
+    log('Python EXE      : %s' % sys.executable)
+    log('Python Version  : %s' % sys.version)
+    log('Python API      : %s' % sys.api_version)
+    log('Kivy Version    : %s' % kivy.__version__)
+    log('Install path    : %s' % os.path.dirname(kivy.__file__))
+    log('Install date    : %s' % ctime(os.path.getctime(kivy.__file__)))
+
+    log('')
+    log('OpenGL information')
+    log('-------------------')
+
+    from kivy.core.gl import glGetString, GL_VENDOR, GL_RENDERER, GL_VERSION
+    log('GL Vendor: %s' % glGetString(GL_VENDOR))
+    log('GL Renderer: %s' % glGetString(GL_RENDERER))
+    log('GL Version: %s' % glGetString(GL_VERSION))
+    log('')
+
+    log('Benchmark')
+    log('---------')
+
+    for x in benchs:
+        # clean cache to prevent weird case
+        for cat in Cache._categories:
+            Cache.remove(cat)
+
+        # force gc before next test
+        gc.collect()
+
+        log('%2d/%-2d %-60s' % (benchs.index(x) + 1,
+            len(benchs), x.__doc__), False)
+        try:
+            sys.stderr.write('.')
+            test = x()
+        except Exception as e:
+            log('failed %s' % str(e))
+            import traceback
+            traceback.print_exc()
+            continue
+
+        clock_start = clockfn()
+
+        try:
+            sys.stderr.write('.')
+            test.run()
+            clock_end = clockfn() - clock_start
+            log('%.6f' % clock_end)
+        except Exception as e:
+            log('failed %s' % str(e))
+            continue
+
+        clock_total += clock_end
+
+    log('')
+    log('Result: %.6f' % clock_total)
+    log('')
+    Clock.stop_clock()
+
+try:
+    reply = input(
+        'Do you want to send benchmark to gist.github.com (Y/n) : ')
+except EOFError:
+    sys.exit(0)
+
+if reply.lower().strip() in ('', 'y'):
+    print('Please wait while sending the benchmark...')
+
+    try:
+        import requests
+    except ImportError:
+        print("`requests` module not found, no benchmark posted.")
+        sys.exit(1)
+
+    payload = {
+        'public': True, 'files': {
+            'benchmark.txt': {
+                'content': '\n'.join(report)}}}
+
+    r = requests.post('https://api.github.com/gists', data=json.dumps(payload))
+
+    print()
+    print()
+    print('REPORT posted at {0}'.format(r.json['html_url']))
+    print()
+    print()
+else:
+    print('No benchmark posted.')
diff --git a/kivy/tools/changelog_parser.py b/kivy/tools/changelog_parser.py
new file mode 100644
index 0000000..bbfdc59
--- /dev/null
+++ b/kivy/tools/changelog_parser.py
@@ -0,0 +1,120 @@
+"""
+Changelog parser
+================
+
+This generates a changelog from a json file of the PRs of a given milestone,
+dumped to json, using the [GitHub CLI](https://github.com/cli/cli).
+
+First, in the command line, create the following alias::
+
+    gh alias set --shell viewMilestone "gh api graphql -F owner='kivy' \
+-F name='kivy' -F number=\\$1 -f query='
+        query GetMilestones(\\$name: String!, \\$owner: String!, \\$number: \
+Int!) {
+            repository(owner: \\$owner, name: \\$name) {
+                milestone(number: \\$number) {
+                    pullRequests(states: MERGED, first: 1000) {
+                        nodes {
+                            number
+                            title
+                            labels (first: 25) {
+                                nodes {
+                                    name
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    '"
+
+Then, log in using ``gh`` and run::
+
+    gh viewMilestone 26 > prs.json
+
+This will generate ``prs.json``. Then, to generate the changelog, run::
+
+    python -m kivy.tools.changelog_parser prs.json changelog.md
+
+to generate a markdown changelog at ``changelog.md``. Then, edit as desired
+and paste into the
+[changelog here](https://github.com/kivy/kivy/blob/master/doc/sources\
+/changelog.rst).
+"""
+from os.path import exists
+import sys
+from collections import defaultdict
+import json
+
+__all__ = ('process_changelog', )
+
+
+def write_special_section(fh, items, header):
+    items = sorted(items, key=lambda x: x[0])
+    if items:
+        fh.write(f'{header}\n{"-" * len(header)}\n\n')
+        for n, title in items:
+            fh.write(f'- [:repo:`{n}`]: {title}\n')
+        fh.write('\n')
+
+
+def process_changelog(filename_in, filename_out):
+    if exists(filename_out):
+        raise ValueError(
+            '{} already exists and would be overwritten'.format(filename_out))
+
+    with open(filename_in, 'r') as fh:
+        data = json.load(fh)
+    prs = data["data"]["repository"]["milestone"]["pullRequests"]["nodes"]
+
+    bad_pr = False
+    grouped = defaultdict(list)
+    highlighted = []
+    api_breaks = []
+    deprecates = []
+    for item in prs:
+        n = item['number']
+        title = item['title']
+        labels = [label['name'] for label in item['labels']['nodes']]
+        api_break = 'Notes: API-break' in labels
+        highlight = 'Notes: Release-highlight' in labels
+        deprecated = 'Notes: API-deprecation' in labels
+        component_str = 'Component: '
+        components = [
+            label[len(component_str):]
+            for label in labels if label.startswith(component_str)
+        ]
+
+        if not components:
+            print(f'Found no component label for #{n}')
+            bad_pr = True
+            continue
+        if len(components) > 1:
+            print(f'Found more than one component label for #{n}')
+            bad_pr = True
+            continue
+
+        grouped[components[0]].append((n, title))
+        if highlight:
+            highlighted.append((n, title))
+        if api_break:
+            api_breaks.append((n, title))
+        if deprecated:
+            deprecates.append((n, title))
+
+    if bad_pr:
+        raise ValueError(
+            'One or more PRs have no, or more than one component label')
+
+    with open(filename_out, 'w') as fh:
+        write_special_section(fh, highlighted, 'Highlights')
+        write_special_section(fh, deprecates, 'Deprecated')
+        write_special_section(fh, api_breaks, 'Breaking changes')
+
+        for group, items in sorted(grouped.items(), key=lambda x: x[0]):
+            write_special_section(fh, items, group.capitalize())
+
+
+if __name__ == '__main__':
+    process_changelog(*sys.argv[1:])
diff --git a/kivy/tools/coverage.py b/kivy/tools/coverage.py
new file mode 100644
index 0000000..5296d76
--- /dev/null
+++ b/kivy/tools/coverage.py
@@ -0,0 +1,135 @@
+"""Kivy coverage plugin
+=======================
+
+This provides a coverage plugin to measure code execution in kv files. To use,
+create and add::
+
+    [run]
+    plugins =
+        kivy.tools.coverage
+
+to the ``.coveragerc`` file in the root of your project. Or::
+
+    [coverage:run]
+    plugins =
+        kivy.tools.coverage
+
+in ``setup.cfg``.
+
+Then you can test your project with e.g. ``pip install coverage`` followed by
+``coverage run --source=./ kivy_app.py`` and ``coverage report``.
+
+Or to use with pytest, ``pip install pytest-cov`` followed by something like
+``pytest --cov=./ .``
+
+TODO: Expand kv statements measured.
+
+Currently, it ignores rules such as Widget creation or graphics object
+creation from being measured. Similarly for import statements.
+
+KV code created as strings within a python file is also not measured. To
+support the above, deeper changes will be required.
+"""
+
+import os
+import coverage
+from kivy.lang.parser import Parser
+
+
+class CoverageKVParser(Parser):
+
+    def execute_directives(self):
+        # don't actually execute anything
+        pass
+
+    def get_coverage_lines(self):
+        lines = set()
+        for parser_prop in walk_parser(self):
+            for line_num, line in enumerate(
+                    parser_prop.value.splitlines(),
+                    start=parser_prop.line + 1):
+                if line.strip():
+                    lines.add(line_num)
+
+        return lines
+
+
+def walk_parser_rules(parser_rule):
+    yield parser_rule
+
+    for child in parser_rule.children:
+        for rule in walk_parser_rules(child):
+            yield rule
+
+    if parser_rule.canvas_before is not None:
+        for rule in walk_parser_rules(parser_rule.canvas_before):
+            yield rule
+        yield parser_rule.canvas_before
+    if parser_rule.canvas_root is not None:
+        for rule in walk_parser_rules(parser_rule.canvas_root):
+            yield rule
+    if parser_rule.canvas_after is not None:
+        for rule in walk_parser_rules(parser_rule.canvas_after):
+            yield rule
+
+
+def walk_parser_rules_properties(parser_rule):
+    for rule in parser_rule.properties.values():
+        yield rule
+    for rule in parser_rule.handlers:
+        yield rule
+
+
+def walk_parser(parser):
+    if parser.root is not None:
+        for rule in walk_parser_rules(parser.root):
+            for prop in walk_parser_rules_properties(rule):
+                yield prop
+
+    for _, cls_rule in parser.rules:
+        for rule in walk_parser_rules(cls_rule):
+            for prop in walk_parser_rules_properties(rule):
+                yield prop
+
+
+class KivyCoveragePlugin(coverage.plugin.CoveragePlugin):
+
+    def file_tracer(self, filename):
+        if filename.endswith('.kv'):
+            return KivyFileTracer(filename=filename)
+        return None
+
+    def file_reporter(self, filename):
+        return KivyFileReporter(filename=filename)
+
+    def find_executable_files(self, src_dir):
+        for (dirpath, dirnames, filenames) in os.walk(src_dir):
+            for filename in filenames:
+                if filename.endswith('.kv'):
+                    yield os.path.join(dirpath, filename)
+
+
+class KivyFileTracer(coverage.plugin.FileTracer):
+
+    filename = ''
+
+    def __init__(self, filename, **kwargs):
+        super(KivyFileTracer, self).__init__(**kwargs)
+        self.filename = filename
+
+    def source_filename(self):
+        return self.filename
+
+
+class KivyFileReporter(coverage.plugin.FileReporter):
+
+    def lines(self):
+        with open(self.filename) as fh:
+            source = fh.read()
+
+        parser = CoverageKVParser(content=source, filename=self.filename)
+        return parser.get_coverage_lines()
+
+
+def coverage_init(reg, options):
+    reg.add_file_tracer(KivyCoveragePlugin())
diff --git a/kivy/tools/gallery.py b/kivy/tools/gallery.py
new file mode 100644
index 0000000..a0d300f
--- /dev/null
+++ b/kivy/tools/gallery.py
@@ -0,0 +1,323 @@
+''' Create rst documentation of the examples directory.
+
+This uses screenshots in the screenshots_dir
+(currently doc/sources/images/examples) along with source code and files
+in the examples/ directory to create rst files in the generation_dir
+(doc/sources/examples) gallery.rst, index.rst, and gen__*.rst
+
+'''
+
+
+import os
+import re
+from os.path import sep
+from os.path import join as slash  # just like that name better
+from os.path import dirname, abspath
+import kivy
+from kivy.logger import Logger
+import textwrap
+
+# from here to the kivy top
+base_dir = dirname(dirname(abspath(kivy.__file__)))
+examples_dir = slash(base_dir, 'examples')
+screenshots_dir = slash(base_dir, 'doc/sources/images/examples')
+generation_dir = slash(base_dir, 'doc/sources/examples')
+
+image_dir = "../images/examples/"  # relative to generation_dir
+gallery_filename = slash(generation_dir, 'gallery.rst')
+
+
+# Info is a dict built up from
+# straight filename information, more from reading the docstring,
+# and more from parsing the description text. Errors are often
+# shown by setting the key 'error' with the value being the error message.
+#
+# It doesn't quite meet the requirements for a class, but is a vocabulary
+# word in this module.
+
+def iter_filename_info(dir_name):
+    """
+    Yield info (dict) of each matching screenshot found walking the
+    directory dir_name. A matching screenshot uses double underscores to
+    separate fields, i.e. path__to__filename__py.png as the screenshot for
+    examples/path/to/filename.py.
+
+    Files not ending with .png are ignored, others are either parsed or
+    yield an error.
+
+    Info fields 'dunder', 'dir', 'file', 'ext', 'source' if not 'error'
+    """
+    pattern = re.compile(r'^((.+)__(.+)__([^-]+))\.png')
+    for t in os.walk(dir_name):
+        for filename in t[2]:
+            if filename.endswith('.png'):
+                m = pattern.match(filename)
+                if m is None:
+                    yield {'error': 'png filename not following screenshot'
+                                    ' pattern: {}'.format(filename)}
+                else:
+                    d = m.group(2).replace('__', sep)
+                    yield {'dunder': m.group(1),
+                           'dir': d,
+                           'file': m.group(3),
+                           'ext': m.group(4),
+                           'source': slash(d, m.group(3) + '.' + m.group(4))
+                           }
+
+
+def parse_docstring_info(text):
+    ''' parse docstring from text (normal string with '\n's) and return an info
+    dict. A docstring should the first triple quoted string, have a title
+    followed by a line of equal signs, and then a description at
+    least one sentence long.
+
+    fields are 'docstring', 'title', and 'first_sentence' if not 'error'
+    'first_sentence' is a single line without newlines.
+    '''
+    q = '\"\"\"|\'\'\''
+    p = r'({})\s+([^\n]+)\s+\=+\s+(.*?)(\1)'.format(q)
+    m = re.search(p, text, re.S)
+    if m:
+        comment = m.group(3).replace('\n', ' ')
+        first_sentence = comment[:comment.find('.') + 1]
+        return {'docstring': m.group(0), 'title': m.group(2),
+                'description': m.group(3), 'first_sentence': first_sentence}
+    else:
+        return {'error': 'Did not find docstring with title at top of file.'}
+
+
+def iter_docstring_info(dir_name):
+    ''' Iterate over screenshots in directory, yield info from the file
+     name and initial parse of the docstring. Errors are logged, but
+     files with errors are skipped.
+    '''
+    for file_info in iter_filename_info(dir_name):
+        if 'error' in file_info:
+            Logger.error(file_info['error'])
+            continue
+        source = slash(examples_dir, file_info['dir'],
+                       file_info['file'] + '.' + file_info['ext'])
+        if not os.path.exists(source):
+            Logger.error('Screen shot references source code that does '
+                         'not exist:  %s', source)
+            continue
+        with open(source) as f:
+            text = f.read()
+            docstring_info = parse_docstring_info(text)
+            if 'error' in docstring_info:
+                Logger.error(docstring_info['error'] + '  File: ' + source)
+                continue  # don't want to show ugly entries
+            else:
+                file_info.update(docstring_info)
+        yield file_info
+
+
+def enhance_info_description(info, line_length=79):
+    ''' Using the info['description'], add fields to info.
+
+    info['files'] is the source filename and any filenames referenced by the
+    magic words in the description, e.g. 'the file xxx.py' or
+    'The image this.png'. These are as written in the description, do
+    not allow ../dir notation, and are relative to the source directory.
+
+    info['enhanced_description'] is the description, as an array of
+    paragraphs where each paragraph is an array of lines wrapped to width
+    line_length. This enhanced description include the rst links to
+    the files of info['files'].
+    '''
+
+    # make text a set of long lines, one per paragraph.
+    paragraphs = info['description'].split('\n\n')
+    lines = [
+        paragraph.replace('\n', '$newline$')
+        for paragraph in paragraphs
+    ]
+    text = '\n'.join(lines)
+
+    info['files'] = [info['file'] + '.' + info['ext']]
+    regex = r'[tT]he (?:file|image) ([\w\/]+\.\w+)'
+    for name in re.findall(regex, text):
+        if name not in info['files']:
+            info['files'].append(name)
+
+    # add links where the files are referenced
+    folder = '_'.join(info['source'].split(sep)[:-1]) + '_'
+    text = re.sub(r'([tT]he (?:file|image) )([\w\/]+\.\w+)',
+                  r'\1:ref:`\2 <$folder$\2>`', text)
+    text = text.replace('$folder$', folder)
+
+    # now break up text into array of paragraphs, each an array of lines.
+    lines = [line.replace('$newline$', '\n') for line in text.split('\n')]
+    paragraphs = [
+        textwrap.wrap(line, line_length)
+        # ignore wrapping if .. note:: or similar block
+        if not line.startswith(' ') else [line]
+        for line in lines
+    ]
+    info['enhanced_description'] = paragraphs
+
+
+def get_infos(dir_name):
+    ''' return infos, an array info dicts for each matching screenshot in the
+    dir, sorted by source file name, and adding the field 'num' as he unique
+    order in this array of dicts'.
+
+    '''
+    infos = [i for i in iter_docstring_info(dir_name)]
+    infos.sort(key=lambda x: x['source'])
+    for num, info in enumerate(infos):
+        info['num'] = num
+        enhance_info_description(info)
+    return infos
+
+
+def make_gallery_page(infos):
+    ''' return string of the rst (Restructured Text) of the gallery page,
+    showing information on all screenshots found.
+    '''
+
+    gallery_top = '''
+Gallery
+-------
+
+.. _Tutorials:  ../tutorials-index.html
+
+.. container:: title
+
+    This gallery lets you explore the many examples included with Kivy.
+    Click on any screenshot to see the code.
+
+This gallery contains:
+
+    * Examples from the examples/ directory that show specific capabilities of
+      different libraries and features of Kivy.
+    * Demonstrations from the examples/demos/ directory that explore many of
+      Kivy's abilities.
+
+There are more Kivy programs elsewhere:
+
+    * Tutorials_ walks through the development of complete Kivy applications.
+    * Unit tests found in the source code under the subdirectory kivy/tests/
+      can also be useful.
+
+We hope your journey into learning Kivy is exciting and fun!
+
+'''
+    output = [gallery_top]
+
+    for info in infos:
+        output.append(
+                "\n**{title}** (:doc:`{source}<gen__{dunder}>`)\n"
+                "\n{description}"
+                "\n.. image:: ../images/examples/{dunder}.png"
+                "\n  :width:  216pt"
+                "\n  :align:  left"
+                "\n  :target: gen__{dunder}.html".format(**info))
+    return "\n".join(output) + "\n"
+
+
+def make_detail_page(info):
+    ''' return str of the rst text for the detail page of the file in info. '''
+
+    def a(s=''):
+        ''' append formatted s to output, which will be joined into lines '''
+        output.append(s.format(**info))
+
+    output = []
+    a('{title}')
+    a('=' * len(info['title']))
+    a('\n.. |pic{num}| image:: /images/examples/{dunder}.png'
+      '\n   :width: 50%'
+      '\n   :align: middle')
+    a('\n|pic{num}|')
+    a()
+    for paragraph in info['enhanced_description']:
+        for line in paragraph:
+            a(line)
+        a()
+
+    # include images
+    last_lang = '.py'
+    for fname in info['files']:
+        full_name = slash(info['dir'], fname)
+        ext = re.search(r'\.\w+$', fname).group(0)
+        a('\n.. _`' + full_name.replace(sep, '_') + '`:')
+        # double separator if building on windows (sphinx skips backslash)
+        if '\\' in full_name:
+            full_name = full_name.replace(sep, sep * 2)
+
+        if ext in ['.png', '.jpg', '.jpeg']:
+            title = 'Image **' + full_name + '**'
+            a('\n' + title)
+            a('~' * len(title))
+            a('\n.. image:: ../../../examples/' + full_name)
+            a('    :align: ' ' center')
+        else:  # code
+            title = 'File **' + full_name + '**'
+            a('\n' + title)
+            a('~' * len(title))
+            if ext != last_lang and ext != '.txt':
+                a('\n.. highlight:: ' + ext[1:])
+                a('    :linenothreshold: 3')
+                last_lang = ext
+            # prevent highlight errors with 'none'
+            elif ext == '.txt':
+                a('\n.. highlight:: none')
+                a('    :linenothreshold: 3')
+                last_lang = ext
+            a('\n.. include:: ../../../examples/' + full_name)
+            a('    :code:')
+    return '\n'.join(output) + '\n'
+
+
+def write_file(name, s):
+    ''' write the string to the filename '''
+
+    # Make sure all the directories has been created before
+    # trying to write to the file
+    directory = os.path.dirname(name)
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    with open(name, 'w') as f:
+        f.write(s)
+
+
+def make_index(infos):
+    ''' return string of the rst for the gallery's index.rst file. '''
+    start_string = '''
+Gallery of Examples
+===================
+
+.. toctree::
+    :maxdepth: 1
+
+    gallery'''
+    output = [start_string]
+    for info in infos:
+        output.append('    gen__{}'.format(info['dunder']))
+    return '\n'.join(output) + '\n'
+
+
+def write_all_rst_pages():
+    ''' Do the main task of writing the gallery,
+    detail, and index rst pages.
+    '''
+    infos = get_infos(screenshots_dir)
+    s = make_gallery_page(infos)
+    write_file(gallery_filename, s)
+
+    for info in infos:
+        s = make_detail_page(info)
+        detail_name = slash(generation_dir,
+                            'gen__{}.rst'.format(info['dunder']))
+        write_file(detail_name, s)
+
+    s = make_index(infos)
+    index_name = slash(generation_dir, 'index.rst')
+    write_file(index_name, s)
+    Logger.info('gallery.py: Created gallery rst documentation pages.')
+
+
+if __name__ == '__main__':
+    write_all_rst_pages()
diff --git a/kivy/tools/generate-icons.py b/kivy/tools/generate-icons.py
new file mode 100644
index 0000000..7a10400
--- /dev/null
+++ b/kivy/tools/generate-icons.py
@@ -0,0 +1,117 @@
+'''
+Icon generator
+==============
+
+This tool will help you to generate all the icons wanted for Google Play Store,
+App Store, Amazon store.
+'''
+
+import sys
+from PIL import Image
+from os.path import exists, join, realpath, basename, dirname
+from os import makedirs
+from argparse import ArgumentParser
+
+
+class Converter(object):
+
+    converters = {
+        'appstore': {
+            'directory_name': 'ios',
+            'sizes': [
+                ('App store high resolution', '{}-appstore-1024.png', 1024),
+                ('App store normal resolution', '{}-appstore-512.png', 512),
+                # iOS 7
+                ('iPhone (iOS 7)', '{}-60.png', 120),
+                ('iPhone @2 (iOS 7)', '{}-60@2x.png', 120),
+                ('iPad (iOS 7)', '{}-76.png', 76),
+                ('iPad @2 (iOS 7)', '{}-60@2x.png', 152),
+                # iOS 6.1 and earlier
+                ('iPhone (iOS >= 6.1)', '{}-57.png', 57),
+                ('iPhone @2 (iOS >= 6.1)', '{}-57@2x.png', 114),
+                ('iPad (iOS >= 6.1)', '{}-72.png', 72),
+                ('iPad @2 (iOS >= 6.1)', '{}-72@2x.png', 114),
+                # iTunes artwork (ad-hoc)
+                ('iTunes Artwork (ad-hoc)', 'iTunesArtwork', 512),
+                ('iTunes Artwork @2 (ad-hoc)', 'iTunesArtwork@2x', 1024),
+            ]},
+        'playstore': {
+            'directory_name': 'android',
+            'sizes': [
+                ('Google Play icon', '{}-googleplay-512.png', 512),
+                ('Launcher icon MDPI', '{}-48.png', 48),
+                ('Launcher icon HDPI', '{}-72.png', 72),
+                ('Launcher icon XHDPI', '{}-96.png', 96),
+                ('Launcher icon XXHDPI', '{}-144.png', 48),
+                ('Launcher icon XXXHDPI', '{}-192.png', 192),
+            ]},
+        'amazonstore': {
+            'directory_name': 'amazon',
+            'sizes': [
+                ('Small icon', '{}-114.png', 114),
+                ('Large icon', '{}-512.png', 512),
+            ]}}
+
+    def run(self):
+        parser = ArgumentParser(
+                description='Generate icons for various stores')
+        parser.add_argument('--dir', type=str, default=None,
+                help=('Output directory to generate all the icons,'
+                      'defaults to the directory of the source icon'))
+        parser.add_argument('--force', type=bool, default=False,
+                help=('Generate all icons even if the source is not perfect.'))
+        parser.add_argument('icon', type=str,
+                help='Base icon (must be 1024x1024 or 512x512)')
+
+        args = parser.parse_args()
+        if not exists(args.icon):
+            print('Error: No such icon file')
+            sys.exit(1)
+
+        # ensure the destination directory will be set
+        if args.dir is None:
+            args.dir = dirname(args.icon)
+
+        # read the source image, and do some quality checks
+        base_fn = basename(args.icon).rsplit('.', 1)[0]
+        source = Image.open(args.icon)
+        self.ensure_quality(source, args.force)
+
+        for directory_name, sizeinfo in self.iterate():
+            description, pattern_fn, size = sizeinfo
+            print('Generate {}: {}x{}'.format(description, size, size))
+            dest_dir = realpath(join(args.dir, directory_name))
+            if not exists(dest_dir):
+                makedirs(dest_dir)
+            icon_fn = join(dest_dir, pattern_fn.format('Icon'))
+            self.convert_to(source, icon_fn, size)
+
+    def convert_to(self, source, icon_fn, size):
+        dest = source.resize((size, size))
+        dest.save(icon_fn, 'png')
+
+    def ensure_quality(self, image, force=False):
+        messages = []
+        w, h = image.size
+        if w != h:
+            messages.append('Width and height should be the same')
+        if w not in (512, 1024):
+            messages.append(
+                'Source image is recommended to be 1024 (512 minimum)')
+        if not messages:
+            return
+
+        print('Quality check failed')
+        for message in messages:
+            print('- {}'.format(message))
+        if not force:
+            sys.exit(1)
+
+    def iterate(self):
+        for store, infos in Converter.converters.items():
+            for size in infos['sizes']:
+                yield infos['directory_name'], size
+
+
+if __name__ == '__main__':
+    Converter().run()
diff --git a/kivy/tools/gles_compat/__pycache__/subset_gles.cpython-310.pyc b/kivy/tools/gles_compat/__pycache__/subset_gles.cpython-310.pyc
new file mode 100644
index 0000000..c1dc8dd
Binary files /dev/null and b/kivy/tools/gles_compat/__pycache__/subset_gles.cpython-310.pyc differ
diff --git a/kivy/tools/gles_compat/gl2.h b/kivy/tools/gles_compat/gl2.h
new file mode 100644
index 0000000..e1d3b87
--- /dev/null
+++ b/kivy/tools/gles_compat/gl2.h
@@ -0,0 +1,621 @@
+#ifndef __gl2_h_
+#define __gl2_h_
+
+/* $Revision: 10602 $ on $Date:: 2010-03-04 22:35:34 -0800 #$ */
+
+#include <GLES2/gl2platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * This document is licensed under the SGI Free Software B License Version
+ * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ .
+ */
+
+/*-------------------------------------------------------------------------
+ * Data type definitions
+ *-----------------------------------------------------------------------*/
+
+typedef void             GLvoid;
+typedef char             GLchar;
+typedef unsigned int     GLenum;
+typedef unsigned char    GLboolean;
+typedef unsigned int     GLbitfield;
+typedef khronos_int8_t   GLbyte;
+typedef short            GLshort;
+typedef int              GLint;
+typedef int              GLsizei;
+typedef khronos_uint8_t  GLubyte;
+typedef unsigned short   GLushort;
+typedef unsigned int     GLuint;
+typedef khronos_float_t  GLfloat;
+typedef khronos_float_t  GLclampf;
+typedef khronos_int32_t  GLfixed;
+
+/* GL types for handling large vertex buffer objects */
+typedef khronos_intptr_t GLintptr;
+typedef khronos_ssize_t  GLsizeiptr;
+
+/* OpenGL ES core versions */
+#define GL_ES_VERSION_2_0                 1
+
+/* ClearBufferMask */
+#define GL_DEPTH_BUFFER_BIT               0x00000100
+#define GL_STENCIL_BUFFER_BIT             0x00000400
+#define GL_COLOR_BUFFER_BIT               0x00004000
+
+/* Boolean */
+#define GL_FALSE                          0
+#define GL_TRUE                           1
+
+/* BeginMode */
+#define GL_POINTS                         0x0000
+#define GL_LINES                          0x0001
+#define GL_LINE_LOOP                      0x0002
+#define GL_LINE_STRIP                     0x0003
+#define GL_TRIANGLES                      0x0004
+#define GL_TRIANGLE_STRIP                 0x0005
+#define GL_TRIANGLE_FAN                   0x0006
+
+/* AlphaFunction (not supported in ES20) */
+/*      GL_NEVER */
+/*      GL_LESS */
+/*      GL_EQUAL */
+/*      GL_LEQUAL */
+/*      GL_GREATER */
+/*      GL_NOTEQUAL */
+/*      GL_GEQUAL */
+/*      GL_ALWAYS */
+
+/* BlendingFactorDest */
+#define GL_ZERO                           0
+#define GL_ONE                            1
+#define GL_SRC_COLOR                      0x0300
+#define GL_ONE_MINUS_SRC_COLOR            0x0301
+#define GL_SRC_ALPHA                      0x0302
+#define GL_ONE_MINUS_SRC_ALPHA            0x0303
+#define GL_DST_ALPHA                      0x0304
+#define GL_ONE_MINUS_DST_ALPHA            0x0305
+
+/* BlendingFactorSrc */
+/*      GL_ZERO */
+/*      GL_ONE */
+#define GL_DST_COLOR                      0x0306
+#define GL_ONE_MINUS_DST_COLOR            0x0307
+#define GL_SRC_ALPHA_SATURATE             0x0308
+/*      GL_SRC_ALPHA */
+/*      GL_ONE_MINUS_SRC_ALPHA */
+/*      GL_DST_ALPHA */
+/*      GL_ONE_MINUS_DST_ALPHA */
+
+/* BlendEquationSeparate */
+#define GL_FUNC_ADD                       0x8006
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_BLEND_EQUATION_RGB             0x8009    /* same as BLEND_EQUATION */
+#define GL_BLEND_EQUATION_ALPHA           0x883D
+
+/* BlendSubtract */
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+
+/* Separate Blend Functions */
+#define GL_BLEND_DST_RGB                  0x80C8
+#define GL_BLEND_SRC_RGB                  0x80C9
+#define GL_BLEND_DST_ALPHA                0x80CA
+#define GL_BLEND_SRC_ALPHA                0x80CB
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+
+/* Buffer Objects */
+#define GL_ARRAY_BUFFER                   0x8892
+#define GL_ELEMENT_ARRAY_BUFFER           0x8893
+#define GL_ARRAY_BUFFER_BINDING           0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895
+
+#define GL_STREAM_DRAW                    0x88E0
+#define GL_STATIC_DRAW                    0x88E4
+#define GL_DYNAMIC_DRAW                   0x88E8
+
+#define GL_BUFFER_SIZE                    0x8764
+#define GL_BUFFER_USAGE                   0x8765
+
+#define GL_CURRENT_VERTEX_ATTRIB          0x8626
+
+/* CullFaceMode */
+#define GL_FRONT                          0x0404
+#define GL_BACK                           0x0405
+#define GL_FRONT_AND_BACK                 0x0408
+
+/* DepthFunction */
+/*      GL_NEVER */
+/*      GL_LESS */
+/*      GL_EQUAL */
+/*      GL_LEQUAL */
+/*      GL_GREATER */
+/*      GL_NOTEQUAL */
+/*      GL_GEQUAL */
+/*      GL_ALWAYS */
+
+/* EnableCap */
+#define GL_TEXTURE_2D                     0x0DE1
+#define GL_CULL_FACE                      0x0B44
+#define GL_BLEND                          0x0BE2
+#define GL_DITHER                         0x0BD0
+#define GL_STENCIL_TEST                   0x0B90
+#define GL_DEPTH_TEST                     0x0B71
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_POLYGON_OFFSET_FILL            0x8037
+#define GL_SAMPLE_ALPHA_TO_COVERAGE       0x809E
+#define GL_SAMPLE_COVERAGE                0x80A0
+
+/* ErrorCode */
+#define GL_NO_ERROR                       0
+#define GL_INVALID_ENUM                   0x0500
+#define GL_INVALID_VALUE                  0x0501
+#define GL_INVALID_OPERATION              0x0502
+#define GL_OUT_OF_MEMORY                  0x0505
+
+/* FrontFaceDirection */
+#define GL_CW                             0x0900
+#define GL_CCW                            0x0901
+
+/* GetPName */
+#define GL_LINE_WIDTH                     0x0B21
+#define GL_ALIASED_POINT_SIZE_RANGE       0x846D
+#define GL_ALIASED_LINE_WIDTH_RANGE       0x846E
+#define GL_CULL_FACE_MODE                 0x0B45
+#define GL_FRONT_FACE                     0x0B46
+#define GL_DEPTH_RANGE                    0x0B70
+#define GL_DEPTH_WRITEMASK                0x0B72
+#define GL_DEPTH_CLEAR_VALUE              0x0B73
+#define GL_DEPTH_FUNC                     0x0B74
+#define GL_STENCIL_CLEAR_VALUE            0x0B91
+#define GL_STENCIL_FUNC                   0x0B92
+#define GL_STENCIL_FAIL                   0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL        0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS        0x0B96
+#define GL_STENCIL_REF                    0x0B97
+#define GL_STENCIL_VALUE_MASK             0x0B93
+#define GL_STENCIL_WRITEMASK              0x0B98
+#define GL_STENCIL_BACK_FUNC              0x8800
+#define GL_STENCIL_BACK_FAIL              0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL   0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS   0x8803
+#define GL_STENCIL_BACK_REF               0x8CA3
+#define GL_STENCIL_BACK_VALUE_MASK        0x8CA4
+#define GL_STENCIL_BACK_WRITEMASK         0x8CA5
+#define GL_VIEWPORT                       0x0BA2
+#define GL_SCISSOR_BOX                    0x0C10
+/*      GL_SCISSOR_TEST */
+#define GL_COLOR_CLEAR_VALUE              0x0C22
+#define GL_COLOR_WRITEMASK                0x0C23
+#define GL_UNPACK_ALIGNMENT               0x0CF5
+#define GL_PACK_ALIGNMENT                 0x0D05
+#define GL_MAX_TEXTURE_SIZE               0x0D33
+#define GL_MAX_VIEWPORT_DIMS              0x0D3A
+#define GL_SUBPIXEL_BITS                  0x0D50
+#define GL_RED_BITS                       0x0D52
+#define GL_GREEN_BITS                     0x0D53
+#define GL_BLUE_BITS                      0x0D54
+#define GL_ALPHA_BITS                     0x0D55
+#define GL_DEPTH_BITS                     0x0D56
+#define GL_STENCIL_BITS                   0x0D57
+#define GL_POLYGON_OFFSET_UNITS           0x2A00
+/*      GL_POLYGON_OFFSET_FILL */
+#define GL_POLYGON_OFFSET_FACTOR          0x8038
+#define GL_TEXTURE_BINDING_2D             0x8069
+#define GL_SAMPLE_BUFFERS                 0x80A8
+#define GL_SAMPLES                        0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE          0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT         0x80AB
+
+/* GetTextureParameter */
+/*      GL_TEXTURE_MAG_FILTER */
+/*      GL_TEXTURE_MIN_FILTER */
+/*      GL_TEXTURE_WRAP_S */
+/*      GL_TEXTURE_WRAP_T */
+
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS     0x86A3
+
+/* HintMode */
+#define GL_DONT_CARE                      0x1100
+#define GL_FASTEST                        0x1101
+#define GL_NICEST                         0x1102
+
+/* HintTarget */
+#define GL_GENERATE_MIPMAP_HINT            0x8192
+
+/* DataType */
+#define GL_BYTE                           0x1400
+#define GL_UNSIGNED_BYTE                  0x1401
+#define GL_SHORT                          0x1402
+#define GL_UNSIGNED_SHORT                 0x1403
+#define GL_INT                            0x1404
+#define GL_UNSIGNED_INT                   0x1405
+#define GL_FLOAT                          0x1406
+#define GL_FIXED                          0x140C
+
+/* PixelFormat */
+#define GL_DEPTH_COMPONENT                0x1902
+#define GL_ALPHA                          0x1906
+#define GL_RGB                            0x1907
+#define GL_RGBA                           0x1908
+#define GL_LUMINANCE                      0x1909
+#define GL_LUMINANCE_ALPHA                0x190A
+
+/* PixelType */
+/*      GL_UNSIGNED_BYTE */
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+
+/* Shaders */
+#define GL_FRAGMENT_SHADER                  0x8B30
+#define GL_VERTEX_SHADER                    0x8B31
+#define GL_MAX_VERTEX_ATTRIBS               0x8869
+#define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
+#define GL_MAX_VARYING_VECTORS              0x8DFC
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS   0x8B4C
+#define GL_MAX_TEXTURE_IMAGE_UNITS          0x8872
+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD
+#define GL_SHADER_TYPE                      0x8B4F
+#define GL_DELETE_STATUS                    0x8B80
+#define GL_LINK_STATUS                      0x8B82
+#define GL_VALIDATE_STATUS                  0x8B83
+#define GL_ATTACHED_SHADERS                 0x8B85
+#define GL_ACTIVE_UNIFORMS                  0x8B86
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH        0x8B87
+#define GL_ACTIVE_ATTRIBUTES                0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH      0x8B8A
+#define GL_SHADING_LANGUAGE_VERSION         0x8B8C
+#define GL_CURRENT_PROGRAM                  0x8B8D
+
+/* StencilFunction */
+#define GL_NEVER                          0x0200
+#define GL_LESS                           0x0201
+#define GL_EQUAL                          0x0202
+#define GL_LEQUAL                         0x0203
+#define GL_GREATER                        0x0204
+#define GL_NOTEQUAL                       0x0205
+#define GL_GEQUAL                         0x0206
+#define GL_ALWAYS                         0x0207
+
+/* StencilOp */
+/*      GL_ZERO */
+#define GL_KEEP                           0x1E00
+#define GL_REPLACE                        0x1E01
+#define GL_INCR                           0x1E02
+#define GL_DECR                           0x1E03
+#define GL_INVERT                         0x150A
+#define GL_INCR_WRAP                      0x8507
+#define GL_DECR_WRAP                      0x8508
+
+/* StringName */
+#define GL_VENDOR                         0x1F00
+#define GL_RENDERER                       0x1F01
+#define GL_VERSION                        0x1F02
+#define GL_EXTENSIONS                     0x1F03
+
+/* TextureMagFilter */
+#define GL_NEAREST                        0x2600
+#define GL_LINEAR                         0x2601
+
+/* TextureMinFilter */
+/*      GL_NEAREST */
+/*      GL_LINEAR */
+#define GL_NEAREST_MIPMAP_NEAREST         0x2700
+#define GL_LINEAR_MIPMAP_NEAREST          0x2701
+#define GL_NEAREST_MIPMAP_LINEAR          0x2702
+#define GL_LINEAR_MIPMAP_LINEAR           0x2703
+
+/* TextureParameterName */
+#define GL_TEXTURE_MAG_FILTER             0x2800
+#define GL_TEXTURE_MIN_FILTER             0x2801
+#define GL_TEXTURE_WRAP_S                 0x2802
+#define GL_TEXTURE_WRAP_T                 0x2803
+
+/* TextureTarget */
+/*      GL_TEXTURE_2D */
+#define GL_TEXTURE                        0x1702
+
+#define GL_TEXTURE_CUBE_MAP               0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP       0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE      0x851C
+
+/* TextureUnit */
+#define GL_TEXTURE0                       0x84C0
+#define GL_TEXTURE1                       0x84C1
+#define GL_TEXTURE2                       0x84C2
+#define GL_TEXTURE3                       0x84C3
+#define GL_TEXTURE4                       0x84C4
+#define GL_TEXTURE5                       0x84C5
+#define GL_TEXTURE6                       0x84C6
+#define GL_TEXTURE7                       0x84C7
+#define GL_TEXTURE8                       0x84C8
+#define GL_TEXTURE9                       0x84C9
+#define GL_TEXTURE10                      0x84CA
+#define GL_TEXTURE11                      0x84CB
+#define GL_TEXTURE12                      0x84CC
+#define GL_TEXTURE13                      0x84CD
+#define GL_TEXTURE14                      0x84CE
+#define GL_TEXTURE15                      0x84CF
+#define GL_TEXTURE16                      0x84D0
+#define GL_TEXTURE17                      0x84D1
+#define GL_TEXTURE18                      0x84D2
+#define GL_TEXTURE19                      0x84D3
+#define GL_TEXTURE20                      0x84D4
+#define GL_TEXTURE21                      0x84D5
+#define GL_TEXTURE22                      0x84D6
+#define GL_TEXTURE23                      0x84D7
+#define GL_TEXTURE24                      0x84D8
+#define GL_TEXTURE25                      0x84D9
+#define GL_TEXTURE26                      0x84DA
+#define GL_TEXTURE27                      0x84DB
+#define GL_TEXTURE28                      0x84DC
+#define GL_TEXTURE29                      0x84DD
+#define GL_TEXTURE30                      0x84DE
+#define GL_TEXTURE31                      0x84DF
+#define GL_ACTIVE_TEXTURE                 0x84E0
+
+/* TextureWrapMode */
+#define GL_REPEAT                         0x2901
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_MIRRORED_REPEAT                0x8370
+
+/* Uniform Types */
+#define GL_FLOAT_VEC2                     0x8B50
+#define GL_FLOAT_VEC3                     0x8B51
+#define GL_FLOAT_VEC4                     0x8B52
+#define GL_INT_VEC2                       0x8B53
+#define GL_INT_VEC3                       0x8B54
+#define GL_INT_VEC4                       0x8B55
+#define GL_BOOL                           0x8B56
+#define GL_BOOL_VEC2                      0x8B57
+#define GL_BOOL_VEC3                      0x8B58
+#define GL_BOOL_VEC4                      0x8B59
+#define GL_FLOAT_MAT2                     0x8B5A
+#define GL_FLOAT_MAT3                     0x8B5B
+#define GL_FLOAT_MAT4                     0x8B5C
+#define GL_SAMPLER_2D                     0x8B5E
+#define GL_SAMPLER_CUBE                   0x8B60
+
+/* Vertex Arrays */
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED        0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE           0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE         0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE           0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED     0x886A
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER        0x8645
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+
+/* Read Format */
+#define GL_IMPLEMENTATION_COLOR_READ_TYPE   0x8B9A
+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
+
+/* Shader Source */
+#define GL_COMPILE_STATUS                 0x8B81
+#define GL_INFO_LOG_LENGTH                0x8B84
+#define GL_SHADER_SOURCE_LENGTH           0x8B88
+#define GL_SHADER_COMPILER                0x8DFA
+
+/* Shader Binary */
+#define GL_SHADER_BINARY_FORMATS          0x8DF8
+#define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
+
+/* Shader Precision-Specified Types */
+#define GL_LOW_FLOAT                      0x8DF0
+#define GL_MEDIUM_FLOAT                   0x8DF1
+#define GL_HIGH_FLOAT                     0x8DF2
+#define GL_LOW_INT                        0x8DF3
+#define GL_MEDIUM_INT                     0x8DF4
+#define GL_HIGH_INT                       0x8DF5
+
+/* Framebuffer Object. */
+#define GL_FRAMEBUFFER                    0x8D40
+#define GL_RENDERBUFFER                   0x8D41
+
+#define GL_RGBA4                          0x8056
+#define GL_RGB5_A1                        0x8057
+#define GL_RGB565                         0x8D62
+#define GL_DEPTH_COMPONENT16              0x81A5
+#define GL_STENCIL_INDEX                  0x1901
+#define GL_STENCIL_INDEX8                 0x8D48
+
+#define GL_RENDERBUFFER_WIDTH             0x8D42
+#define GL_RENDERBUFFER_HEIGHT            0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT   0x8D44
+#define GL_RENDERBUFFER_RED_SIZE          0x8D50
+#define GL_RENDERBUFFER_GREEN_SIZE        0x8D51
+#define GL_RENDERBUFFER_BLUE_SIZE         0x8D52
+#define GL_RENDERBUFFER_ALPHA_SIZE        0x8D53
+#define GL_RENDERBUFFER_DEPTH_SIZE        0x8D54
+#define GL_RENDERBUFFER_STENCIL_SIZE      0x8D55
+
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         0x8CD2
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+
+#define GL_COLOR_ATTACHMENT0              0x8CE0
+#define GL_DEPTH_ATTACHMENT               0x8D00
+#define GL_STENCIL_ATTACHMENT             0x8D20
+
+#define GL_NONE                           0
+
+#define GL_FRAMEBUFFER_COMPLETE                      0x8CD5
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT         0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS         0x8CD9
+#define GL_FRAMEBUFFER_UNSUPPORTED                   0x8CDD
+
+#define GL_FRAMEBUFFER_BINDING            0x8CA6
+#define GL_RENDERBUFFER_BINDING           0x8CA7
+#define GL_MAX_RENDERBUFFER_SIZE          0x84E8
+
+#define GL_INVALID_FRAMEBUFFER_OPERATION  0x0506
+
+/*-------------------------------------------------------------------------
+ * GL core functions.
+ *-----------------------------------------------------------------------*/
+
+GL_APICALL void         GL_APIENTRY glActiveTexture (GLenum texture);
+GL_APICALL void         GL_APIENTRY glAttachShader (GLuint program, GLuint shader);
+GL_APICALL void         GL_APIENTRY glBindAttribLocation (GLuint program, GLuint index, const GLchar* name);
+GL_APICALL void         GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer);
+GL_APICALL void         GL_APIENTRY glBindFramebuffer (GLenum target, GLuint framebuffer);
+GL_APICALL void         GL_APIENTRY glBindRenderbuffer (GLenum target, GLuint renderbuffer);
+GL_APICALL void         GL_APIENTRY glBindTexture (GLenum target, GLuint texture);
+GL_APICALL void         GL_APIENTRY glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+GL_APICALL void         GL_APIENTRY glBlendEquation ( GLenum mode );
+GL_APICALL void         GL_APIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
+GL_APICALL void         GL_APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
+GL_APICALL void         GL_APIENTRY glBlendFuncSeparate (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+GL_APICALL void         GL_APIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
+GL_APICALL void         GL_APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
+GL_APICALL GLenum       GL_APIENTRY glCheckFramebufferStatus (GLenum target);
+GL_APICALL void         GL_APIENTRY glClear (GLbitfield mask);
+GL_APICALL void         GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+GL_APICALL void         GL_APIENTRY glClearDepthf (GLclampf depth);
+GL_APICALL void         GL_APIENTRY glClearStencil (GLint s);
+GL_APICALL void         GL_APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+GL_APICALL void         GL_APIENTRY glCompileShader (GLuint shader);
+GL_APICALL void         GL_APIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);
+GL_APICALL void         GL_APIENTRY glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);
+GL_APICALL void         GL_APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GL_APICALL void         GL_APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GL_APICALL GLuint       GL_APIENTRY glCreateProgram (void);
+GL_APICALL GLuint       GL_APIENTRY glCreateShader (GLenum type);
+GL_APICALL void         GL_APIENTRY glCullFace (GLenum mode);
+GL_APICALL void         GL_APIENTRY glDeleteBuffers (GLsizei n, const GLuint* buffers);
+GL_APICALL void         GL_APIENTRY glDeleteFramebuffers (GLsizei n, const GLuint* framebuffers);
+GL_APICALL void         GL_APIENTRY glDeleteProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glDeleteRenderbuffers (GLsizei n, const GLuint* renderbuffers);
+GL_APICALL void         GL_APIENTRY glDeleteShader (GLuint shader);
+GL_APICALL void         GL_APIENTRY glDeleteTextures (GLsizei n, const GLuint* textures);
+GL_APICALL void         GL_APIENTRY glDepthFunc (GLenum func);
+GL_APICALL void         GL_APIENTRY glDepthMask (GLboolean flag);
+GL_APICALL void         GL_APIENTRY glDepthRangef (GLclampf zNear, GLclampf zFar);
+GL_APICALL void         GL_APIENTRY glDetachShader (GLuint program, GLuint shader);
+GL_APICALL void         GL_APIENTRY glDisable (GLenum cap);
+GL_APICALL void         GL_APIENTRY glDisableVertexAttribArray (GLuint index);
+GL_APICALL void         GL_APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
+GL_APICALL void         GL_APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
+GL_APICALL void         GL_APIENTRY glEnable (GLenum cap);
+GL_APICALL void         GL_APIENTRY glEnableVertexAttribArray (GLuint index);
+GL_APICALL void         GL_APIENTRY glFinish (void);
+GL_APICALL void         GL_APIENTRY glFlush (void);
+GL_APICALL void         GL_APIENTRY glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+GL_APICALL void         GL_APIENTRY glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GL_APICALL void         GL_APIENTRY glFrontFace (GLenum mode);
+GL_APICALL void         GL_APIENTRY glGenBuffers (GLsizei n, GLuint* buffers);
+GL_APICALL void         GL_APIENTRY glGenerateMipmap (GLenum target);
+GL_APICALL void         GL_APIENTRY glGenFramebuffers (GLsizei n, GLuint* framebuffers);
+GL_APICALL void         GL_APIENTRY glGenRenderbuffers (GLsizei n, GLuint* renderbuffers);
+GL_APICALL void         GL_APIENTRY glGenTextures (GLsizei n, GLuint* textures);
+GL_APICALL void         GL_APIENTRY glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetActiveUniform (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetAttachedShaders (GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
+GL_APICALL int          GL_APIENTRY glGetAttribLocation (GLuint program, const GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetBooleanv (GLenum pname, GLboolean* params);
+GL_APICALL void         GL_APIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint* params);
+GL_APICALL GLenum       GL_APIENTRY glGetError (void);
+GL_APICALL void         GL_APIENTRY glGetFloatv (GLenum pname, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetIntegerv (GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);
+GL_APICALL void         GL_APIENTRY glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog);
+GL_APICALL void         GL_APIENTRY glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
+GL_APICALL void         GL_APIENTRY glGetShaderSource (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
+GL_APICALL const GLubyte* GL_APIENTRY glGetString (GLenum name);
+GL_APICALL void         GL_APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetUniformfv (GLuint program, GLint location, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetUniformiv (GLuint program, GLint location, GLint* params);
+GL_APICALL int          GL_APIENTRY glGetUniformLocation (GLuint program, const GLchar* name);
+GL_APICALL void         GL_APIENTRY glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat* params);
+GL_APICALL void         GL_APIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid** pointer);
+GL_APICALL void         GL_APIENTRY glHint (GLenum target, GLenum mode);
+GL_APICALL GLboolean    GL_APIENTRY glIsBuffer (GLuint buffer);
+GL_APICALL GLboolean    GL_APIENTRY glIsEnabled (GLenum cap);
+GL_APICALL GLboolean    GL_APIENTRY glIsFramebuffer (GLuint framebuffer);
+GL_APICALL GLboolean    GL_APIENTRY glIsProgram (GLuint program);
+GL_APICALL GLboolean    GL_APIENTRY glIsRenderbuffer (GLuint renderbuffer);
+GL_APICALL GLboolean    GL_APIENTRY glIsShader (GLuint shader);
+GL_APICALL GLboolean    GL_APIENTRY glIsTexture (GLuint texture);
+GL_APICALL void         GL_APIENTRY glLineWidth (GLfloat width);
+GL_APICALL void         GL_APIENTRY glLinkProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glPixelStorei (GLenum pname, GLint param);
+GL_APICALL void         GL_APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
+GL_APICALL void         GL_APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
+GL_APICALL void         GL_APIENTRY glReleaseShaderCompiler (void);
+GL_APICALL void         GL_APIENTRY glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+GL_APICALL void         GL_APIENTRY glSampleCoverage (GLclampf value, GLboolean invert);
+GL_APICALL void         GL_APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+GL_APICALL void         GL_APIENTRY glShaderBinary (GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);
+GL_APICALL void         GL_APIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar** string, const GLint* length);
+GL_APICALL void         GL_APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilMask (GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilMaskSeparate (GLenum face, GLuint mask);
+GL_APICALL void         GL_APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
+GL_APICALL void         GL_APIENTRY glStencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
+GL_APICALL void         GL_APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
+GL_APICALL void         GL_APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
+GL_APICALL void         GL_APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat* params);
+GL_APICALL void         GL_APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+GL_APICALL void         GL_APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint* params);
+GL_APICALL void         GL_APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
+GL_APICALL void         GL_APIENTRY glUniform1f (GLint location, GLfloat x);
+GL_APICALL void         GL_APIENTRY glUniform1fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform1i (GLint location, GLint x);
+GL_APICALL void         GL_APIENTRY glUniform1iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniform2f (GLint location, GLfloat x, GLfloat y);
+GL_APICALL void         GL_APIENTRY glUniform2fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform2i (GLint location, GLint x, GLint y);
+GL_APICALL void         GL_APIENTRY glUniform2iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniform3f (GLint location, GLfloat x, GLfloat y, GLfloat z);
+GL_APICALL void         GL_APIENTRY glUniform3fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform3i (GLint location, GLint x, GLint y, GLint z);
+GL_APICALL void         GL_APIENTRY glUniform3iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniform4f (GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GL_APICALL void         GL_APIENTRY glUniform4fv (GLint location, GLsizei count, const GLfloat* v);
+GL_APICALL void         GL_APIENTRY glUniform4i (GLint location, GLint x, GLint y, GLint z, GLint w);
+GL_APICALL void         GL_APIENTRY glUniform4iv (GLint location, GLsizei count, const GLint* v);
+GL_APICALL void         GL_APIENTRY glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void         GL_APIENTRY glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void         GL_APIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+GL_APICALL void         GL_APIENTRY glUseProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glValidateProgram (GLuint program);
+GL_APICALL void         GL_APIENTRY glVertexAttrib1f (GLuint indx, GLfloat x);
+GL_APICALL void         GL_APIENTRY glVertexAttrib1fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttrib2f (GLuint indx, GLfloat x, GLfloat y);
+GL_APICALL void         GL_APIENTRY glVertexAttrib2fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttrib3f (GLuint indx, GLfloat x, GLfloat y, GLfloat z);
+GL_APICALL void         GL_APIENTRY glVertexAttrib3fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttrib4f (GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+GL_APICALL void         GL_APIENTRY glVertexAttrib4fv (GLuint indx, const GLfloat* values);
+GL_APICALL void         GL_APIENTRY glVertexAttribPointer (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr);
+GL_APICALL void         GL_APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __gl2_h_ */
diff --git a/kivy/tools/gles_compat/subset_gles.py b/kivy/tools/gles_compat/subset_gles.py
new file mode 100644
index 0000000..1bd65af
--- /dev/null
+++ b/kivy/tools/gles_compat/subset_gles.py
@@ -0,0 +1,125 @@
+'''
+    Common GLES Subset Extraction Script
+    ====================================
+
+    In Kivy, our goal is to use OpenGL ES 2.0 (GLES2) for all drawing on all
+    platforms. The problem is that GLES2 is not a proper subset of any OpenGL
+    Desktop (GL) version prior to version 4.1.
+    However, to keep all our drawing cross-platform compatible, we're
+    restricting the Kivy drawing core to a real subset of GLES2 that is
+    available on all platforms.
+
+    This script therefore parses the GL and GL Extension (GLEXT) headers and
+    compares them with the GLES2 header. It then generates a header that only
+    contains symbols that are common to GLES2 and at least either GL or GLEXT.
+    However, since GLES2 doesn't support double values, we also need to do some
+    renaming, because functions in GL that took doubles as arguments now take
+    floats in GLES2, with their function name being suffixed with 'f'.
+
+    Furthermore, sometimes the pure symbol name doesn't match because there
+    might be an _EXT or _ARB or something akin to that at the end of a symbol
+    name. In that case, we take the symbol from the original header and add
+    a #define directive to redirect to that symbol from the symbol name without
+    extension.
+'''
+
+from __future__ import print_function
+
+gl = open("/Developer/SDKs/MacOSX10.6.sdk/System/Library/Frameworks/" +
+          "OpenGL.framework/Versions/A/Headers/gl.h", 'r')
+glext = open("/Developer/SDKs/MacOSX10.6.sdk/System/Library/Frameworks/" +
+             "OpenGL.framework/Versions/A/Headers/glext.h", 'r')
+gles = open("gl2.h", 'r')
+
+
+def add_defines_to_set(header):
+    symbols = []
+    lineno = 0
+    for line in header:
+        symbol = None
+        hexcode = None
+        lineno += 1
+        line = line.strip()
+        try:
+            elements = line.split()
+            if line.startswith("#define"):
+                symbol = elements[1]
+                for element in elements:
+                    if element.startswith("0x"):
+                        hexcode = element
+            elif line.startswith("typedef"):
+                symbol = elements[-1]
+            else:
+                for element in elements:
+                    if element.startswith("gl"):
+                        symbol = element
+            if symbol:
+                symbols.append((symbol, lineno, line, hexcode))
+        except Exception as e:
+            print('error:', lineno, ':', line)
+            print(e)
+
+    return symbols
+
+
+def extract_common_symbols(symbols1, symbols2, already_extracted):
+    for symbol1, lineno1, line1, hexcode1 in symbols1:
+        for symbol2, lineno2, line2, hexcode2 in symbols2:
+            if symbol1 in already_extracted or symbol2 in already_extracted:
+                continue
+            if symbol1 == symbol2 + 'f':
+                # There is no `double` type in GLES; Functions that were using
+                # a double were renamed with the suffix 'f'.
+                print("// Different Name; Redefine")
+                print(line2)
+                print("#define %s %s" % (symbol1, symbol2))
+            elif symbol1 == symbol2:
+                already_extracted.append(symbol1)
+                print(line1)
+                if symbol1 == 'GLclampf;':
+                    # See explanation about doubles on GLES above.
+                    print('typedef GLclampf GLclampd;')
+            elif hexcode1 and hexcode2 and hexcode1 == hexcode2:
+                already_extracted.append(symbol1)
+                already_extracted.append(symbol2)
+                print("// Different Name; Redefine")
+                print(line2)
+                print("#define %s %s" % (symbol1, symbol2))
+
+
+# Generate ------------------------------------------------
+# pipe to kivy/kivy/graphics/common_subset.h
+
+gl_symbols = add_defines_to_set(gl)
+glext_symbols = add_defines_to_set(glext)
+gles_symbols = add_defines_to_set(gles)
+
+print('// GLES 2.0 Header file, generated for Kivy')
+print('// Check kivy/kivy/tools/gles_compat/subset_gles.py')
+print('#pragma once')
+print('#include "gl2platform.h"')
+print('#ifdef __cplusplus')
+print('extern "C" {')
+print('#endif')
+
+# Don't add the same symbol more than once
+already_extracted = []
+
+print('\n// Subset common to GLES and GL: ===================================')
+extract_common_symbols(gles_symbols, gl_symbols, already_extracted)
+
+print('\n// Subset common to GLES and GLEXT: ================================')
+extract_common_symbols(gles_symbols, glext_symbols, already_extracted)
+
+print()
+print('// What follows was manually extracted from the GLES2 headers because')
+print('// it was not present in any other header.', end=' ')
+print('''
+#define GL_SHADER_BINARY_FORMATS          0x8DF8
+#define GL_RGB565                         0x8D62
+''')
+
+print('#ifdef __cplusplus')
+print('}')
+print('#endif')
+print('\n')
diff --git a/kivy/tools/highlight/__init__.py b/kivy/tools/highlight/__init__.py
new file mode 100644
index 0000000..0b4bfc1
--- /dev/null
+++ b/kivy/tools/highlight/__init__.py
@@ -0,0 +1,9 @@
+'''
+Syntax Highlighting
+===================
+
+This module contains various files for providing Kivy syntax highlighting in
+some popular text editors. Please see the contents of this folder for the
+provided resources.
+
+'''
diff --git a/kivy/tools/highlight/__pycache__/__init__.cpython-310.pyc b/kivy/tools/highlight/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..9252671
Binary files /dev/null and b/kivy/tools/highlight/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/tools/highlight/kivy-mode.el b/kivy/tools/highlight/kivy-mode.el
new file mode 100644
index 0000000..b50cabe
--- /dev/null
+++ b/kivy/tools/highlight/kivy-mode.el
@@ -0,0 +1,293 @@
+;;; kivy-mode.el --- Emacs major mode for editing Kivy files
+;;
+;; Author: Dean Serenevy <dean@serenevy.net>
+;; Version: 0.1.0
+;;
+;; This document borrowed heavily from yaml-mode.el by Yoshiki Kurihara and
+;; Marshall Vandegrift.
+;;
+;; This file is not part of Emacs
+
+
+;; This file is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by the
+;; Free Software Foundation; version 3.
+
+;; This file is distributed in the hope that it will be useful, but WITHOUT
+;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+;; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+;; more details.
+
+;; You should have received a copy of the GNU General Public License along
+;; with GNU Emacs; see the file COPYING. If not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
+;; USA.
+
+;;; Installation:
+
+;; To install, just drop this file into a directory in your `load-path' and
+;; (optionally) byte-compile it. To automatically handle files ending in
+;; '.kv', add something like:
+;;
+;;    (require 'kivy-mode)
+;;    (add-to-list 'auto-mode-alist '("\\.kv$" . kivy-mode))
+;;
+;; to your .emacs file.
+;;
+;; This mode does not enable electric-indent by default. To get this
+;; behavior, either enable electric-indent-mode globally or enable it only
+;; for kivy buffers using `kivy-mode-hook':
+;;
+;;    (add-hook 'kivy-mode-hook
+;;     '(lambda ()
+;;        (electric-indent-local-mode t)))
+
+
+;; User definable variables
+
+(defgroup kivy nil
+  "Support for the kivy user interface definition format"
+  :group 'languages
+  :prefix "kivy-")
+
+(defcustom kivy-mode-hook nil
+  "*Hook run by `kivy-mode'."
+  :type 'hook
+  :group 'kivy)
+
+(defcustom kivy-indent-offset 4
+  "*Amount of offset per level of indentation."
+  :type 'integer
+  :group 'kivy)
+
+(defcustom kivy-backspace-function 'backward-delete-char-untabify
+  "*Function called by `kivy-electric-backspace' when deleting backwards."
+  :type 'function
+  :group 'kivy)
+
+(defface kivy-tab-face
+  '((((class color)) (:background "red" :foreground "red" :bold t))
+    (t (:reverse-video t)))
+  "Face to use for highlighting tabs in kivy files."
+  :group 'faces
+  :group 'kivy)
+
+(defcustom kivy-imenu-generic-expression
+  '((nil  "^\\([<>a-zA-Z_-]+\\):"          1))
+  "The imenu regex to parse an outline of the kivy file."
+  :type 'string
+  :group 'kivy)
+
+
+;; Constants
+
+(defconst kivy-mode-version "0.1.0" "Version of `kivy-mode.'")
+
+(defconst kivy-blank-line-re "^ *$"
+  "Regexp matching a line containing only (valid) whitespace.")
+
+(defconst kivy-comment-re "\\(?:^\\|\\s-+\\)\\(#.*\\)"
+  "Regexp matching a line containing a kivy comment or delimiter.")
+
+(defconst kivy-directive-re "^\\(?:#:\\)\\(\\w+ +.*\\)"
+  "Regexp matching a line containing a kivy directive.")
+
+(defconst kivy-tag-re "^ *id: *\\([^ \n]+\\)$"
+  "Rexexp matching a kivy tag.")
+
+(defconst kivy-bare-scalar-re
+  "\\(?:[^-:,#!\n{\\[ ]\\|[^#!\n{\\[ ]\\S-\\)[^#\n]*?"
+  "Rexexp matching a kivy bare scalar.")
+
+(defconst kivy-hash-key-re
+  (concat "^ *"
+          "\\(" kivy-bare-scalar-re "\\) *:"
+          "\\(?: +\\|$\\)")
+  "Regexp matching a single kivy hash key.")
+
+(defconst kivy-nested-map-re
+  (concat ".*: *$")
+  "Regexp matching a line beginning a kivy nested structure.")
+
+(defconst kivy-constant-scalars-re
+  (concat "\\(?:^\\|\\(?::\\|-\\|,\\|{\\|\\[\\) +\\) *"
+          (regexp-opt
+           '("True" "False" "None") t)
+          " *$")
+  "Regexp matching certain scalar constants in scalar context")
+
+
+
+;; Mode setup
+
+(defvar kivy-mode-map ()
+  "Keymap used in `kivy-mode' buffers.")
+(if kivy-mode-map
+    nil
+  (setq kivy-mode-map (make-sparse-keymap))
+  (define-key kivy-mode-map [backspace] 'kivy-electric-backspace)
+  (define-key kivy-mode-map "\C-c<" 'kivy-indent-shift-left)
+  (define-key kivy-mode-map "\C-c>" 'kivy-indent-shift-right)
+  )
+
+(defvar kivy-mode-syntax-table nil
+  "Syntax table in use in kivy-mode buffers.")
+(if kivy-mode-syntax-table
+    nil
+  (setq kivy-mode-syntax-table (make-syntax-table))
+  (modify-syntax-entry ?\' "\"" kivy-mode-syntax-table)
+  (modify-syntax-entry ?\" "\"" kivy-mode-syntax-table)
+  (modify-syntax-entry ?# "<" kivy-mode-syntax-table)
+  (modify-syntax-entry ?\n ">" kivy-mode-syntax-table)
+  (modify-syntax-entry ?\\ "\\" kivy-mode-syntax-table)
+  (modify-syntax-entry ?- "_" kivy-mode-syntax-table)
+  (modify-syntax-entry ?_ "w" kivy-mode-syntax-table)
+  (modify-syntax-entry ?< "." kivy-mode-syntax-table)
+  (modify-syntax-entry ?> "." kivy-mode-syntax-table)
+  (modify-syntax-entry ?_ "_" kivy-mode-syntax-table)
+  )
+
+
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.kv$" . kivy-mode))
+
+
+;;;###autoload
+(define-derived-mode kivy-mode fundamental-mode "kivy"
+  "Simple mode to edit kivy.
+
+\\{kivy-mode-map}"
+  (set (make-local-variable 'comment-start) "# ")
+  (set (make-local-variable 'comment-start-skip) "#+ *")
+  (set (make-local-variable 'indent-line-function) 'kivy-indent-line)
+  (set (make-local-variable 'font-lock-defaults)
+       '(kivy-font-lock-keywords
+         nil nil nil nil
+         (font-lock-syntactic-keywords))))
+
+
+;; Font-lock support
+
+(defvar kivy-font-lock-keywords
+  (list
+   (cons kivy-comment-re '(1 font-lock-comment-face))
+   (cons kivy-constant-scalars-re '(1 font-lock-constant-face))
+   (cons kivy-tag-re '(1 font-lock-function-name-face))
+   (cons kivy-hash-key-re '(1 font-lock-variable-name-face t))
+   (cons kivy-directive-re '(1 font-lock-builtin-face))
+   '("^[\t]+" 0 'kivy-tab-face t))
+  "Additional expressions to highlight in kivy mode.")
+
+(defvar kivy-font-lock-syntactic-keywords
+  (list '())
+  "Additional syntax features to highlight in kivy mode.")
+
+
+;; Indentation and electric keys
+
+(defun kivy-compute-indentation ()
+  "Calculate the maximum sensible indentation for the current line."
+  (save-excursion
+    (beginning-of-line)
+    (forward-line -1)
+    (while (and (looking-at kivy-blank-line-re)
+                (> (point) (point-min)))
+      (forward-line -1))
+    (+ (current-indentation)
+       (if (looking-at kivy-nested-map-re) kivy-indent-offset 0)
+       )))
+
+(defun kivy-indent-line ()
+  "Indent the current line.
+The first time this command is used, the line will be indented to the
+maximum sensible indentation.  Each immediately subsequent usage will
+back-dent the line by `kivy-indent-offset' spaces.  On reaching column
+0, it will cycle back to the maximum sensible indentation."
+  (interactive "*")
+  (let ((ci (current-indentation))
+        (cc (current-column))
+        (need (kivy-compute-indentation)))
+    (save-excursion
+      (beginning-of-line)
+      (delete-horizontal-space)
+      (if (and (equal last-command this-command) (/= ci 0))
+          (indent-to (* (/ (- ci 1) kivy-indent-offset) kivy-indent-offset))
+        (indent-to need)))
+    (if (< (current-column) (current-indentation))
+        (forward-to-indentation 0))))
+
+(defun kivy-electric-backspace (arg)
+  "Delete characters or back-dent the current line.
+If invoked following only whitespace on a line, will back-dent to the
+immediately previous multiple of `kivy-indent-offset' spaces."
+  (interactive "*p")
+  (if (or (/= (current-indentation) (current-column)) (bolp))
+      (funcall kivy-backspace-function arg)
+    (let ((ci (current-column)))
+      (beginning-of-line)
+      (delete-horizontal-space)
+      (indent-to (* (/ (- ci (* arg kivy-indent-offset))
+                       kivy-indent-offset)
+                    kivy-indent-offset)))))
+
+
+(defun kivy-set-imenu-generic-expression ()
+  (make-local-variable 'imenu-generic-expression)
+  (make-local-variable 'imenu-create-index-function)
+  (setq imenu-create-index-function 'imenu-default-create-index-function)
+  (setq imenu-generic-expression kivy-imenu-generic-expression))
+
+(add-hook 'kivy-mode-hook 'kivy-set-imenu-generic-expression)
+(add-hook 'kivy-mode-hook
+          '(lambda ()
+             (setq indent-tabs-mode 'nil)))
+
+
+(defun kivy-mode-version ()
+  "Display version of `kivy-mode'."
+  (interactive)
+  (message "kivy-mode %s" kivy-mode-version)
+  kivy-mode-version)
+
+(defun kivy-indent-shift-left (start end &optional count)
+  "Shift lines contained in region START END by COUNT columns to the left.
+COUNT defaults to `kivy-indent-offset'.  If region isn't
+active, the current line is shifted.  The shifted region includes
+the lines in which START and END lie.  An error is signaled if
+any lines in the region are indented less than COUNT columns."
+  (interactive
+   (if mark-active
+       (list (region-beginning) (region-end) current-prefix-arg)
+     (list (line-beginning-position) (line-end-position) current-prefix-arg)))
+  (if count
+      (setq count (prefix-numeric-value count))
+    (setq count kivy-indent-offset))
+  (when (> count 0)
+    (let ((deactivate-mark nil))
+      (save-excursion
+        (goto-char start)
+        (while (< (point) end)
+          (if (and (< (current-indentation) count)
+                   (not (looking-at "[ \t]*$")))
+              (error "Can't shift all lines enough"))
+          (forward-line))
+        (indent-rigidly start end (- count))))))
+
+(defun kivy-indent-shift-right (start end &optional count)
+  "Shift lines contained in region START END by COUNT columns to the left.
+COUNT defaults to `kivy-indent-offset'.  If region isn't
+active, the current line is shifted.  The shifted region includes
+the lines in which START and END lie."
+  (interactive
+   (if mark-active
+       (list (region-beginning) (region-end) current-prefix-arg)
+     (list (line-beginning-position) (line-end-position) current-prefix-arg)))
+  (let ((deactivate-mark nil))
+    (if count
+        (setq count (prefix-numeric-value count))
+      (setq count kivy-indent-offset))
+    (indent-rigidly start end count)))
+
+(provide 'kivy-mode)
+
+;;; kivy-mode.el ends here
diff --git a/kivy/tools/highlight/kivy.json-tmlanguage b/kivy/tools/highlight/kivy.json-tmlanguage
new file mode 100644
index 0000000..627094f
--- /dev/null
+++ b/kivy/tools/highlight/kivy.json-tmlanguage
@@ -0,0 +1,20 @@
+{ "name": "Kivy Language",
+  "scopeName": "source.python.kivy",
+  "fileTypes": ["kv"],
+  "patterns": [
+    { "match": "#:.*?$",
+      "name": "support.type.kivy" },
+    { "match": "#.*?$",
+      "name": "comment.kivy" },
+    { "match": "\\<.+\\>",
+      "name": "support.class.kivy" },
+    { "match": "[A-Za-z][A-Za-z0-9]+$",
+      "name": "support.function.kivy" },
+    { "match": ".*?:$",
+      "name": "support.function.kivy" },
+    { "name": "entity.name.section.kivy",
+      "match": "(.*?):$" },
+    { "include": "source.python" }
+  ],
+  "uuid": "49cecc44-5094-48ec-a876-91f597e8bf81"
+}
\ No newline at end of file
diff --git a/kivy/tools/highlight/kivy.tmLanguage b/kivy/tools/highlight/kivy.tmLanguage
new file mode 100644
index 0000000..2adf1a5
--- /dev/null
+++ b/kivy/tools/highlight/kivy.tmLanguage
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>fileTypes</key>
+	<array>
+		<string>kv</string>
+	</array>
+	<key>name</key>
+	<string>Kivy Language</string>
+	<key>patterns</key>
+	<array>
+		<dict>
+			<key>match</key>
+			<string>#:.*?$</string>
+			<key>name</key>
+			<string>support.type.kivy</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>#.*?$</string>
+			<key>name</key>
+			<string>comment.kivy</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>\&lt;.+\&gt;</string>
+			<key>name</key>
+			<string>support.class.kivy</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>[A-Za-z][A-Za-z0-9]+$</string>
+			<key>name</key>
+			<string>support.function.kivy</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>.*?:$</string>
+			<key>name</key>
+			<string>support.function.kivy</string>
+		</dict>
+		<dict>
+			<key>match</key>
+			<string>(.*?):$</string>
+			<key>name</key>
+			<string>entity.name.section.kivy</string>
+		</dict>
+		<dict>
+			<key>include</key>
+			<string>source.python</string>
+		</dict>
+	</array>
+	<key>scopeName</key>
+	<string>source.python.kivy</string>
+	<key>uuid</key>
+	<string>49cecc44-5094-48ec-a876-91f597e8bf81</string>
+</dict>
+</plist>
diff --git a/kivy/tools/highlight/kivy.vim b/kivy/tools/highlight/kivy.vim
new file mode 100644
index 0000000..301108d
--- /dev/null
+++ b/kivy/tools/highlight/kivy.vim
@@ -0,0 +1,47 @@
+" ~/.vim/after/syntax/kivy.vim
+"
+" Vim syntax file
+" Language:	Kivy
+" Maintainer:	Gabriel Pettier <gabriel.pettier@gmail.com>
+" Last Change:	2020 June 23
+
+syntax clear
+
+syn include @pyth $VIMRUNTIME/syntax/python.vim
+
+syn match kivyComment       /#.*\n/ display contains=pythonTodo,Spell
+syn match kivyPreProc       /^\s*#:.*/
+syn match kivyRule          /<-*\I\i*\%([,@+]\I\i*\)*>:/
+syn match kivyRule          /\[-*\I\i*\%([,@+]\I\i*\)*]:/
+syn match kivyRootRule      /^\I\i*:\s*$/
+
+syn region kivyAttrBlock    matchgroup=kivyAttribute start=/^\z(\s\+\)\I\i*\s*:\s*$/ skip="^\s*$" end="^\%(\z1\s\{4}\)\@!" contains=@pyth
+syn region kivyAttrBlock    matchgroup=kivyAttribute start=/^\s\+\I\i*\s*:\%(\s*\S\)\@=/ end="$" keepend oneline contains=@pyth
+
+syn region kivyId           matchgroup=kivyAttribute start=/^\s\+id\s*:\s*/ end="\w\+\zs" oneline
+
+syn region kivyBindBlock    matchgroup=kivyBind start=/^\z(\s\+\)on_\I\i*\s*:\s*$/ skip="^\s*$" end="^\%(\z1\s\{4}\)\@!" contains=@pyth
+syn region kivyBindBlock    matchgroup=kivyBind start=/^\s\+on_\i\+\s*:\%(\s*\S\)\@=/ end="$" keepend oneline contains=@pyth
+
+syn region kivyCanvasValue  matchgroup=kivyCanvas start=/^\z(\s\+\)\I\i*\s*:\s*$/ skip="^\s*$" end="^\%(\z1\s\{4}\)\@!" contains=@pyth contained
+syn region kivyCanvasValue  matchgroup=kivyCanvas start=/^\s\+\I\i*\s*:\%(\s*\S\)\@=/ end="$" keepend oneline contains=@pyth contained
+syn region kivyCanvas       matchgroup=kivyCanvas start=/^\z(\s\+\)canvas.*:\s*$/ skip="^\s*$" end="^\%(\z1\s\{4}\)\@!"
+                            \   contains=kivyInstruction,kivyPreProc,kivyComment,kivyCanvasValue
+
+syn match kivyInstruction   /^\s\+\u\i*\s*:/ contained
+syn match kivyWidget        /^\s\+\u\i*\s*:/
+
+hi def link kivyPreproc     PreProc
+hi def link kivyComment     Comment
+hi def link kivyRule        Type
+hi def link kivyRootRule    Function
+hi def link kivyAttribute   Label
+hi def link kivyBind        Function
+hi def link kivyWidget      Function
+hi def link kivyCanvas      special
+hi def link kivyInstruction Statement
+
+hi KivyId cterm=underline
+hi KivyPreproc cterm=bold
+
+let b:current_syntax = "kivy"
diff --git a/kivy/tools/image-testsuite/README.md b/kivy/tools/image-testsuite/README.md
new file mode 100644
index 0000000..7fc048f
--- /dev/null
+++ b/kivy/tools/image-testsuite/README.md
@@ -0,0 +1,148 @@
+Generating the image test suite
+-------------------------------
+
+On Linux/unix systems, you can use the `imagemagick-testsuite.sh` script
+to create an image test suite using the `convert` command line utility. You
+must have ImageMagick installed ("apt install imagemagick" on debian
+derivatives). There is also a rule in the Makefile, `make image-testsuite`.
+
+A more comprehensive test suite can be generated using Gimp (tested on
+version 2.8.18). To install the plugin, copy `gimp28-testsuite.py` to your
+gimp plugins directory, on linux/unix systems usually `~/.gimp-2.8/plug-ins`.
+You can find the plugin location via the Gimp menu `Edit` - `Preferences` -
+`Folders` - `Plug-Ins`. Once installed, the plugin should appear in "Tools"
+menu, named "Kivy image testsuite".
+
+Test images must be saved in the `kivy/tests/image-testsuite` directory,
+after this you can run the test. It is (currently) preferable to run it
+directly as a script, instead of via `make test`, since the latter won't
+give you useful debug output.
+
+    cd kivy/tests
+    python test_imageloader.py | less
+
+or to get only the summary report:
+
+    python test_imageloader.py | grep REPORT | less
+
+
+Kivy ImageLoader testsuite
+--------------------------
+
+These tools generate a wide range of images for testing Kivy's ImageLoaders.
+The pixel data is encoded in the file name, and reproduced "from the sideline"
+in order to verify the pixel data loaded from file. This is used to expose
+issues in the Kivy core and underlying provider libraries.
+
+The filenames consist of sections separated by an underscore `_`:
+
+    v0_ <W> x <H> _ <pat> _ <alpha> _ <fmt> _ <testname> _ <encoder> . <ext>
+
+Variables are enclosed in pointy brackets. The leading `v0_` indicates that
+it conforms to version 0 of the test protocol (described in this document)
+and must be present.
+
+    v0_5x1_rgb_FF_PNG24_OPAQUE_magick.png
+
+This is a 5x1 image, pattern is "rgb", alpha is "FF". `PNG24` is the internal
+file format name (ImageMagick-specific), and `OPAQUE` is the test we  are
+performing (drawing opaque pixels only), see test names below.
+
+* <pattern> indicates the pixel colors (in order), as they are drawn in the
+  image file.
+
+* <alpha> is the global alpha from 00-FF (2 bytes, ascii) which is applied to
+  all pixels except 't' (transparent) which have fixed alpha at 00
+
+* <fmt> (aka fmtinfo) is an encoder-specific string with information about the
+  format or process that generated the file. For example, if the same image
+  is saved with and without interlacing, it will contain "I1" and "I0" to
+  distinguish the files.
+  * ImageMagick test suite generator uses magick format name, such as `PNG24`
+  * The Gimp generator plugin adds information about the layer that was
+    exported to form the image:
+      * BPP1G = 1 byte per pixel, gray
+      * BPP2GA = 2 bytes per pixel, gray + alpha
+      * BPP3 = 3 bytes per pixel, rgb
+      * BPP4 = 4 bytes per pixel, rgba
+      * IX = indexed, IXA = indexed+alpha
+      * Note: Indexed images are drawn in RGB or GRAY images (with alpha if
+        needed), and converted to indexed before export. These values
+        represent the layer type at time of export, it affects the parameters
+        used for encoding the output data.
+
+* <testname> is a special string that indicates what type of data is expected
+  in the file. Options are OPAQUE, BINARY, ALPHA and repeated for grayscale,
+  GRAY-OPAQUE, GRAY-BINARY, GRAY-ALPHA. We expect BINARY and ALPHA tests to
+  result in an alpha channel (details below)
+
+* <encoder> identifies the software that created the file, "magick", "gimp" ..
+
+* <ext> is the extension, must be lowercase and match the extensions
+  supported by Kivy image loaders (or they will be ignored)
+
+
+Test names
+----------
+
+* `OPAQUE` tests opaque pixels (normal RGB) (lossess formats)
+* `BINARY` tests opaque + fully transparent pixels (GIF etc)
+* `ALPHA` tests semi-transparent pixels (normal RGBA) (PNG32 etc)
+* `GRAY-OPAQUE` tests opaque grayscale only (various PNG, tga, )
+* `GRAY-BINARY` tests opaque grayscale + fully transparent pixels (PNGs)
+* `GRAY-ALPHA` tests semi-transparent grayscale pixels (TGA, XCF)
+
+Patterns must conform to the specific test. For example, the pattern "rgb" has
+undefined behavior for a grayscale test, since r/g/b can't be represented
+in grayscale. So all grayscale formats must use 0-9A-F only, and optionally 
+'t' for transparent pixels in GRAY-BINARY/GRAY-ALPHA.
+
+
+| Test name    | Valid pattern characters                                    |
+| -----------: | :---------------------------------------------------------- |
+| OPAQUE       | `wxrgbcyp`, and full grayscale\*\*                          |
+| GRAY-OPAQUE  | `0123456789ABCDEF` (full grayscale)                         |
+| BINARY       | `t` REQUIRED + `wrgbcyp`, limited grayscale (no 0/x!!!)     |
+| GRAY-BINARY  | `t` REQUIRED + limited grayscale (no 0/x!!!)                |
+| ALPHA        | `t`, `wxrbgcyp` and full grayscale\*\*                      |
+| GRAY-ALPHA   | `t`, `0123456789ABCDEF` (full grayscale)                    |
+
+* `**`: While grayscale is supported here, it is generally better to use
+  colors, since all the bytes in a grayscale pixel represented as rgb are
+  identical. For example, 'A' or \xAA\xAA\xAA will pass despite a byte
+  order problem.
+
+* `!!!`: In some cases, black color is used for binary transparency. So
+  if you use "0" (or "x"), test_imageloader will expect #000000FF in RGBA,
+  but the pixel becomes transparent (a=00) and test fails. All BINARY tests
+  **MUST** include at least one "t" pixel to ensure that the image is
+  saved with an alpha channel.
+
+
+Pixel values
+------------
+
+Each character in the pattern represents the color of a single pixel. It is
+important that you include only the correct type of pixel values for the
+different test types (see table above). Individual pixel values get their
+alpha from global setting (<alpha> in filename), but 't' pixels always have
+alpha = 0x00 regardless of the test's alpha setting.
+
+
+    OPAQUE, BINARY, ALPHA (lowercase)
+    -----------------------------------------
+    "w" White (#fff)     "x" Black  (#000)!!!
+    "r" Red   (#f00)     "g" Green  (#0f0)
+    "b" Blue  (#00f)     "y" Yellow (#ff0)
+    "c" Cyan  (#0ff)     "p" Purple (#f0f)
+
+
+    GRAY-OPAQUE, GRAY-BINARY, GRAY-ALPHA (uppercase)
+    ------------------------------------------------
+    "0" #000!!!  "1" #111     "2" #222     "3" #333
+    "4" #444     "5" #555     "6" #666     "7" #777
+    "8" #888     "9" #999     "A" #AAA     "B" #BBB
+    "C" #CCC     "D" #DDD     "E" #EEE     "F" #FFF
+
+    !!! See warnings above regarding BINARY tests
+
diff --git a/kivy/tools/image-testsuite/__pycache__/gimp28-testsuite.cpython-310.pyc b/kivy/tools/image-testsuite/__pycache__/gimp28-testsuite.cpython-310.pyc
new file mode 100644
index 0000000..27dfd48
Binary files /dev/null and b/kivy/tools/image-testsuite/__pycache__/gimp28-testsuite.cpython-310.pyc differ
diff --git a/kivy/tools/image-testsuite/gimp28-testsuite.py b/kivy/tools/image-testsuite/gimp28-testsuite.py
new file mode 100755
index 0000000..a4b78d7
--- /dev/null
+++ b/kivy/tools/image-testsuite/gimp28-testsuite.py
@@ -0,0 +1,329 @@
+#!/usr/bin/env python
+# flake8: noqa
+import os
+import re
+import random
+from gimpfu import *
+
+# Test suite configuration - key is test name, values are:
+#
+# alpha....: global alpha, used for all pixels except 't'
+# patterns.: allowed v0 pattern characters (+ force include and exclude)
+# *_IMAGE..: gimp layer types to export for this test, w/target extensions
+TESTSUITE_CONFIG = {
+    'OPAQUE': {
+        'alpha': [255],
+        'patterns': ('wxrgbcyp', None, None),
+        RGB_IMAGE: ['xcf', 'png', 'tga', 'tiff', 'ppm',
+                    'sgi', 'pcx', 'fits', 'ras'],
+        INDEXED_IMAGE: ['xcf', 'png', 'tga', 'tiff', 'ppm', 'gif', 'ras'],
+    },
+
+    'GRAY-OPAQUE': {
+        'alpha': [255],
+        'patterns': ('0123456789ABCDEF', None, None),
+        GRAY_IMAGE: ['xcf', 'png', 'tga', 'tiff',
+                     'pgm', 'sgi', 'fits', 'ras'],
+        INDEXED_IMAGE: ['xcf', 'png', 'tga', 'tiff', 'pgm', 'fits', 'ras'],
+    },
+
+    'BINARY': {
+        'alpha': [255],
+        'patterns': ('twrgbcyp', 't', None),
+        RGBA_IMAGE: ['xcf', 'png', 'tga', 'ico', 'sgi'],
+        INDEXEDA_IMAGE: ['xcf', 'png', 'tga', 'gif'],
+    },
+    'GRAY-BINARY': {
+        'alpha': [255],
+        'patterns': ('t123456789ABCDEF', 't', None),
+        GRAYA_IMAGE: ['xcf', 'tga', 'png', 'sgi'],
+        INDEXEDA_IMAGE: ['xcf', 'tga', 'png'],
+    },
+
+    "ALPHA": {
+        'alpha': [0x7F, 0xF0],
+        'patterns': ('twxrgbcyp', None, None),
+        RGBA_IMAGE: ['xcf', 'png', 'tga', 'sgi'],
+    },
+    'GRAY-ALPHA': {
+        'alpha': [0x7F, 0xF0],
+        'patterns': ('t0123456789ABCDEF', None, None),
+        GRAYA_IMAGE: ['xcf', 'png', 'tga', 'sgi'],
+    },
+}
+
+
+# kivy image test protocol v0 data: key is pattern char, value is pixel w/o a
+v0_PIXELS = {
+    'w': [0xFF, 0xFF, 0xFF], 'x': [0x00, 0x00, 0x00], 'r': [0xFF, 0x00, 0x00],
+    'g': [0x00, 0xFF, 0x00], 'b': [0x00, 0x00, 0xFF], 'y': [0xFF, 0xFF, 0x00],
+    'c': [0x00, 0xFF, 0xFF], 'p': [0xFF, 0x00, 0xFF], '0': [0x00, 0x00, 0x00],
+    '1': [0x11, 0x11, 0x11], '2': [0x22, 0x22, 0x22], '3': [0x33, 0x33, 0x33],
+    '4': [0x44, 0x44, 0x44], '5': [0x55, 0x55, 0x55], '6': [0x66, 0x66, 0x66],
+    '7': [0x77, 0x77, 0x77], '8': [0x88, 0x88, 0x88], '9': [0x99, 0x99, 0x99],
+    'A': [0xAA, 0xAA, 0xAA], 'B': [0xBB, 0xBB, 0xBB], 'C': [0xCC, 0xCC, 0xCC],
+    'D': [0xDD, 0xDD, 0xDD], 'E': [0xEE, 0xEE, 0xEE], 'F': [0xFF, 0xFF, 0xFF]}
+
+
+# kivy image test protocol v0: return pixel data for given pattern char
+def v0_pattern_pixel(char, alpha, fmt):
+    if fmt == 'rgba':
+        if char == 't':
+            return [0, 0, 0, 0]
+        return v0_PIXELS[char] + [alpha]
+    if fmt == 'rgb':
+        if char == 't':
+            return [0, 0, 0]
+        return v0_PIXELS[char]
+    if fmt == 'gray':
+        assert char in '0123456789ABCDEF'
+        return [v0_PIXELS[char][0]]
+    if fmt == 'graya':
+        assert char in 't0123456789ABCDEF'
+        if char == 't':
+            return [0, 0]
+        return [v0_PIXELS[char][0]] + [alpha]
+    raise Exception('v0_pattern_pixel: unknown format {}'.format(fmt))
+
+
+# kivy image test protocol v0: filename
+def v0_filename(w, h, pat, alpha, fmtinfo, testname, ext):
+    return 'v0_{}x{}_{}_{:02X}_{}_{}_gimp.{}'.format(
+            w, h, pat, alpha, fmtinfo, testname, ext)
+
+
+# Saves an image to one or more files. We can't specify these details when
+# saving by extension. (This declaration is PEP8 compliant, 's all good)
+def save_image(dirname, img, lyr, w, h, pat, alpha, v0_fmtinfo, testname, ext):
+    def filename(fmtinfo_in=None):
+        fmtinfo = fmtinfo_in and v0_fmtinfo + '-' + fmtinfo_in or v0_fmtinfo
+        return v0_filename(w, h, pat, alpha, fmtinfo, testname, ext)
+
+    def savepath(fn):
+        return os.path.join(dirname, fn)
+
+    if ext in ('ppm', 'pgm', 'pbm', 'pnm', 'pam'):
+        fn = filename('ASCII')
+        pdb.file_pnm_save(img, lyr, savepath(fn), fn, 0)
+        fn = filename('RAW')
+        pdb.file_pnm_save(img, lyr, savepath(fn), fn, 1)
+
+    elif ext == 'tga':
+        # FIXME: Last argument to file_tga_save is undocumented, not sure what
+        fn = filename('RAW')
+        pdb.file_tga_save(img, lyr, savepath(fn), fn, 0, 0)
+        fn = filename('RLE')
+        pdb.file_tga_save(img, lyr, savepath(fn), fn, 1, 0)
+
+    elif ext == 'gif':
+        fn = filename('I0')
+        pdb.file_gif_save(img, lyr, savepath(fn), fn, 0, 0, 0, 0)
+        fn = filename('I1')
+        pdb.file_gif_save(img, lyr, savepath(fn), fn, 1, 0, 0, 0)
+
+    elif ext == 'png':
+        bits = [0, 1]
+        # interlaced, bkgd block, gama block
+        for i, b, g in [(i, b, g) for i in bits for b in bits for g in bits]:
+            fn = filename('I{}B{}G{}'.format(i, b, g))
+            pdb.file_png_save(img, lyr, savepath(fn), fn, i, 9, b, g, 1, 1, 1)
+
+    elif ext == 'sgi':
+        fn = filename('RAW')
+        pdb.file_sgi_save(img, lyr, savepath(fn), fn, 0)
+        fn = filename('RLE')
+        pdb.file_sgi_save(img, lyr, savepath(fn), fn, 1)
+        fn = filename('ARLE')
+        pdb.file_sgi_save(img, lyr, savepath(fn), fn, 2)
+
+    elif ext == 'tiff':
+        fn = filename('RAW')
+        pdb.file_tiff_save(img, lyr, savepath(fn), fn, 0)
+        fn = filename('LZW')
+        pdb.file_tiff_save(img, lyr, savepath(fn), fn, 1)
+        fn = filename('PACKBITS')
+        pdb.file_tiff_save(img, lyr, savepath(fn), fn, 2)
+        fn = filename('DEFLATE')
+        pdb.file_tiff_save(img, lyr, savepath(fn), fn, 3)
+
+    elif ext == 'ras':
+        fn = filename('RAW')
+        pdb.file_sunras_save(img, lyr, savepath(fn), fn, 0)
+        fn = filename('RLE')
+        pdb.file_sunras_save(img, lyr, savepath(fn), fn, 1)
+
+    else:
+        fn = filename()
+        pdb.gimp_file_save(img, lyr, savepath(fn), fn)
+
+
+# Draw pattern on layer, helper for make_images() below
+def draw_pattern(lyr, pat, alpha, direction, pixelgetter):
+    assert 0 <= alpha <= 255
+    assert re.match('[twxrgbycp0-9A-F]+$', pat)
+    assert direction in ('x', 'y', 'width', 'height')
+    dirx = direction in ('x', 'width')
+    for i in range(0, len(pat)):
+        pixel = pixelgetter(pat[i], alpha)
+        if dirx:
+            pdb.gimp_drawable_set_pixel(lyr, i, 0, len(pixel), pixel)
+        else:
+            pdb.gimp_drawable_set_pixel(lyr, 0, i, len(pixel), pixel)
+
+
+# Create an image from the given pattern, with the specified layertype_in*,
+# draw the pattern with given alpha, and save to the given extensions. Gimp
+# adjust the encoder accordingly.
+# * cheat for indexed formats: draw in RGB(A) and let gimp make palette
+def make_images(testname, pattern, alpha, layertype_in, extensions, dirname):
+    assert testname.upper() == testname
+    assert len(pattern) > 0
+    assert len(extensions) > 0
+    assert isinstance(extensions, (list, tuple))
+    assert re.match('[wxtrgbcypA-F0-9]+$', pattern)
+
+    test_alpha = 'ALPHA' in testname or 'BINARY' in testname
+    grayscale = 'GRAY' in testname
+
+    # Indexed layer types are drawn in RGB/RGBA, and converted later
+    imgtype, v0_fmtinfo = {
+        GRAY_IMAGE: (GRAY, 'BPP1G'),
+        GRAYA_IMAGE: (GRAY, 'BPP2GA'),
+        RGB_IMAGE: (RGB, 'BPP3'),
+        RGBA_IMAGE: (RGB, 'BPP4'),
+        INDEXED_IMAGE: (grayscale and GRAY or RGB, 'IX'),
+        INDEXEDA_IMAGE: (grayscale and GRAY or RGB, 'IXA'),
+    }[layertype_in]
+
+    # We need to supply pixels of the format of the layer
+    PP = v0_pattern_pixel
+    pixelgetter = {
+        GRAY_IMAGE: lambda c, a: PP(c, a, 'gray'),
+        GRAYA_IMAGE: lambda c, a: PP(c, a, 'graya'),
+        RGB_IMAGE: lambda c, a: PP(c, a, 'rgb'),
+        RGBA_IMAGE: lambda c, a: PP(c, a, 'rgba'),
+        INDEXED_IMAGE: lambda c, a: PP(c, a, grayscale and 'gray' or 'rgb'),
+        INDEXEDA_IMAGE: lambda c, a: PP(c, a, grayscale and 'graya' or 'rgba'),
+    }[layertype_in]
+
+    # Pick the correct layer type for indexed formats
+    layertype = {
+        INDEXED_IMAGE: grayscale and GRAY_IMAGE or RGB_IMAGE,
+        INDEXEDA_IMAGE: grayscale and GRAYA_IMAGE or RGBA_IMAGE,
+    }.get(layertype_in, layertype_in)
+
+    # Draw pattern Nx1 and 1xN variations
+    for direction in 'xy':
+        # Create the gimp image, and the layer we will draw on
+        w, h = (direction == 'x') and (len(pattern), 1) or (1, len(pattern))
+        img = pdb.gimp_image_new(w, h, imgtype)
+        lyr = pdb.gimp_layer_new(img, w, h, layertype, 'P', 100, NORMAL_MODE)
+
+        # Add alpha layer if we are planning on encoding alpha information
+        if test_alpha:
+            pdb.gimp_layer_add_alpha(lyr)
+            pdb.gimp_drawable_fill(lyr, TRANSPARENT_FILL)
+        pdb.gimp_image_add_layer(img, lyr, 0)
+
+        # Draw it
+        draw_pattern(lyr, pattern, alpha, direction, pixelgetter)
+
+        # Convert to indexed before saving, if needed
+        if layertype_in in (INDEXED_IMAGE, INDEXEDA_IMAGE):
+            colors = len(set(pattern)) + (test_alpha and 1 or 0)
+            pdb.gimp_convert_indexed(img, 0, 0, colors, 0, 0, "ignored")
+
+        # Save each individual extension
+        for ext in extensions:
+            save_image(dirname, img, lyr,
+                       w, h, pattern, alpha, v0_fmtinfo, testname, ext)
+        # FIXME: this fails?
+        # pdb.gimp_image_delete(img)
+
+
+# FIXME: pattern generation needs thought, this sucks..
+def makepatterns(allow, include=None, exclude=None):
+    src = set()
+    src.update([x for x in allow])
+    src.update([allow[:i] for i in range(1, len(allow) + 1)])
+    for i in range(len(allow)):
+        pick1, pick2 = random.choice(allow), random.choice(allow)
+        src.update([pick1 + pick2])
+    for i in range(3, 11) + range(14, 18) + range(31, 34):
+        src.update([''.join([random.choice(allow) for k in range(i)])])
+    out = []
+    for srcpat in src:
+        if exclude and exclude in srcpat:
+            continue
+        if include and include not in srcpat:
+            out.append(include + srcpat[1:])
+            continue
+        out.append(srcpat)
+    return list(set(out))
+
+
+def plugin_main(dirname, do_opaque, do_binary, do_alpha):
+    if not dirname:
+        pdb.gimp_message("No output directory selected, aborting")
+        return
+    if not os.path.isdir(dirname) or not os.access(dirname, os.W_OK):
+        pdb.gimp_message("Invalid / non-writeable output directory, aborting")
+        return
+
+    tests = []
+    tests.extend({
+        0: ['OPAQUE', 'GRAY-OPAQUE'],
+        2: ['OPAQUE'],
+        3: ['GRAY-OPAQUE'],
+    }.get(do_opaque, []))
+    tests.extend({
+        0: ['BINARY', 'GRAY-BINARY'],
+        2: ['BINARY'],
+        3: ['GRAY-BINARY'],
+    }.get(do_binary, []))
+    tests.extend({
+        0: ['ALPHA', 'GRAY-ALPHA'],
+        2: ['ALPHA'],
+        3: ['GRAY-ALPHA'],
+    }.get(do_alpha, []))
+
+    suite_cfg = dict(TESTSUITE_CONFIG)
+    for testname, cfg in suite_cfg.items():
+        if testname not in tests:
+            continue
+        pchars, inc, exc = cfg.pop('patterns')
+        if not pchars:
+            continue
+        patterns = makepatterns(pchars, inc, exc)
+        for alpha in cfg.pop('alpha', [255]):
+            for layertype, exts in cfg.items():
+                if not exts:
+                    continue
+                for p in patterns:
+                    make_images(testname, p, alpha, layertype, exts, dirname)
+
+
+register(
+    proc_name="kivy_image_testsuite",
+    help="Creates image test suite for Kivy ImageLoader",
+    blurb=("Creates image test suite for Kivy ImageLoader. "
+          "Warning: This will create thousands of images"),
+    author="For kivy.org, Terje Skjaeveland",
+    copyright="Copyright 2017 kivy.org (MIT license)",
+    date="2017",
+    imagetypes="",
+    params=[
+        (PF_DIRNAME, "outputdir", "Output directory:", 0),
+        (PF_OPTION, "opaque", "OPAQUE tests?", 0,
+                    ["All", "None", "OPAQUE", "GRAY-OPAQUE"]),
+        (PF_OPTION, "binary", "BINARY tests?", 0,
+                    ["All", "None", "BINARY", "GRAY-BINARY"]),
+        (PF_OPTION, "alpha", "ALPHA tests?", 0,
+                    ["All", "None", "ALPHA", "GRAY-ALPHA"]),
+    ],
+    results=[],
+    function=plugin_main,
+    menu="<Image>/Tools/_Kivy image testsuite...",
+    label="Generate images...")
+
+main()
diff --git a/kivy/tools/image-testsuite/imagemagick-testsuite.sh b/kivy/tools/image-testsuite/imagemagick-testsuite.sh
new file mode 100755
index 0000000..e62a9bb
--- /dev/null
+++ b/kivy/tools/image-testsuite/imagemagick-testsuite.sh
@@ -0,0 +1,238 @@
+#!/usr/bin/env sh
+
+# ImageMagickFormat:extension
+FMT_OPAQUE="TIFF:tiff BMP:bmp BMP3:bmp PNG:png GIF87:gif CUR:cur \
+            PPM:ppm FITS:fits RAS:ras"
+FMT_BINARY="BMP:bmp GIF:gif PNG8:png PNG24:png PNG48:png ICO:ico"
+FMT_ALPHA="PNG32:png PNG64:png TGA:tga SGI:sgi DPX:dpx"
+
+# FIXME: Magick output is not completely predictable. Some images
+# become gray+alpha, some palette, some bitonal, and it's not obvious
+# how/if this can be controlled better
+#FMT_BITONAL=""
+FMT_GRAY_OPAQUE="PGM:pgm FITS:fits RAS:ras"
+FMT_GRAY_BINARY="PNG8:png"
+FMT_GRAY_ALPHA="PNG:png TGA:tga"
+
+# Pixel values used for different tests
+PIX_alpha="twxrgbcyp48A"
+PIX_opaque="wxrgbcyp48A"
+PIX_binary="twrgbcyp48A"
+PIX_gray_opaque="0123456789ABCDEF"
+PIX_gray_binary="t123456789ABCDEF"
+PIX_gray_alpha="t0123456789ABCDEF"
+
+
+usage() { cat <<EOM
+Usage: $0 <target-directory>
+
+  Creates test images in many formats using ImageMagick 'convert'
+  utility. The pixel values are encoded in the filename, so they
+  can be reconstructed and verified independently. This system
+  is referred to as the image test protocol (version 0). 
+
+  More info: kivy/tools/image-testsuite/README.md
+EOM
+}
+
+# Outputs command line arguments for convert to draw pixels from the
+# specified pattern in the specified direction. It is always 1 in w or h.
+draw_pattern() {
+    pattern=$1
+    direction="${2:-x}"
+    pos=0
+    for char in $(echo $pattern | fold -w1); do
+        case $char in
+            t) fill="#00000000" ;;
+            w) fill="#FFFFFF${TESTALPHA}" ;;
+            x) fill="#000000${TESTALPHA}" ;;
+            r) fill="#FF0000${TESTALPHA}" ;;
+            g) fill="#00FF00${TESTALPHA}" ;;
+            b) fill="#0000FF${TESTALPHA}" ;;
+            y) fill="#FFFF00${TESTALPHA}" ;;
+            c) fill="#00FFFF${TESTALPHA}" ;;
+            p) fill="#FF00FF${TESTALPHA}" ;;
+            0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F)
+                fill="#${char}${char}${char}${char}${char}${char}${TESTALPHA}"
+            ;;
+            *) (>&2 echo "Error: Invalid pattern char: $char"); exit 100 ;;
+        esac
+        case $direction in
+            y|height) echo -n "-draw 'fill $fill color 0, $pos point' " ;;
+            x|width)  echo -n "-draw 'fill $fill color $pos, 0 point' " ;;
+        esac
+        pos=$((pos+1))
+    done
+}
+
+# Creates 1xN and Nx1 test images from the given pattern, in the given
+# format. Only use alpha != FF if you are actually testing alpha.
+make_images() {
+    pattern=$1
+    len=${#pattern}
+
+    if [ -z $pattern ] || [ -z $TESTFMT ] || [ -z $TESTEXT ]; then
+        (>&2 echo "make_images() missing required arguments/environment")
+        exit 101
+    fi
+    if [ ${#TESTALPHA} != 2 ]; then
+        (>&2 echo "make_images() invalid TESTALPHA: $TESTALPHA")
+        exit 102
+    fi
+
+    # Nx1
+    ending="${TESTALPHA}_${TESTFMT}_${TESTNAME}_magick.${TESTEXT}"
+    outfile="v0_${len}x1_${pattern}_${ending}"
+    eval convert -size ${len}x1 xc:none -quality 100% $TESTARGS \
+        $(draw_pattern "$pattern" "x") \
+        ${convert_args} \
+        "${TESTFMT}:$destdir/$outfile"
+
+    # 1xN - don't create duplicates for single pixel
+    if [ $len -ne 1 ]; then
+        outfile="v0_1x${len}_${pattern}_${ending}"
+        eval convert -size 1x${len} xc:none -quality 100% $TESTARGS \
+            $(draw_pattern "$pattern" "y") \
+            "${TESTFMT}:$destdir/$outfile"
+    fi
+}
+
+# Make a random pattern from given characters $1 at length $2
+# FIXME: portability?
+mkpattern() {
+    < /dev/urandom LC_ALL=C tr -dc "$1" | head -c $2
+}
+
+# Makes simple permutations and random patterns, optionally with
+# prefix and postfix (args are pattern, prefix, postfix)
+permutepattern() {
+    if [ -z "$1" ]; then
+        (>&2 echo "permutepattern() missing required argument")
+        exit 200
+    fi
+
+    # Individual pixel values + poor permutation FIXME
+    for char in $(echo $1 | fold -w1); do
+        echo -n "$2${char}$3 "
+        if [ ! -z $p1 ]; then echo -n "$2${char}${p1}$3 "; fi
+# Uncomment for more data
+#        if [ ! -z $p2 ]; then echo -n "$2${char}${p1}${p2}$3 "; fi
+#        if [ ! -z $p3 ]; then echo -n "$2${char}${p1}${p2}${p3}$3 "; fi
+#        if [ ! -z $p4 ]; then echo -n "$2${char}${p1}${p2}${p3}${p4}$3 "; fi
+        p4=$p3 ; p3=$p2 ; p2=$p1 ; p1=$char
+    done
+
+    # Random
+    for i in $(seq 3 9) $(seq 14 17) $(seq 31 33); do
+        echo -n "$2$(mkpattern "$1" "$i")$3 "
+    done
+}
+
+# ------------------------------------------------------------
+# Main
+# ------------------------------------------------------------
+if [ "$#" -ne 1 ] || [ -z "$1" ]; then
+    echo "Usage: $0 <target-directory>  (or -h for help)"
+    exit 1
+fi
+
+case $1 in
+    -h|--help) usage; exit 1 ;;
+esac
+
+if [ ! -d "$1" ]; then
+    (>&2 echo "Error: Destination directory '$1' does not exist")
+    exit 2
+elif [ ! -w "$1" ]; then
+    (>&2 echo "Error: Destination directory '$1' not writeable")
+    exit 2
+fi
+destdir=$(cd "$1"; echo $(pwd))
+
+if [ ! -x "$(command -v convert)" ]; then
+    (2>&1 echo "Required ImageMagick 'convert' not found in path")
+    exit 3
+fi
+
+
+# - Opaque patterns only include solid colors, alpha is fixed at FF
+# - Binary patterns MUST include 't' pixels and MUST NOT include 'x' or '0'
+# - Alpha can combine any pixel value and use alpha != FF
+PAT_opaque=$(permutepattern "$PIX_opaque")
+PAT_binary=$(permutepattern "$PIX_binary" "t")
+PAT_alpha="${PAT_binary} $(permutepattern "$PIX_alpha")"
+
+# Grayscale patterns use only grayscale pixel values + 't' and alpha,
+# ie #000 #111 #222 .. #EEE #FFF (0 1 2 .. E F in patterns)
+PAT_gray_opaque=$(permutepattern "$PIX_gray_opaque")
+PAT_gray_binary=$(permutepattern "$PIX_gray_binary" "t")
+PAT_gray_alpha="${PAT_gray_binary} $(permutepattern "$PIX_gray_alpha")"
+
+start() {
+    TESTNAME="$1"
+    TESTARGS="$2"
+    TESTALPHA="FF"
+    TESTFMT=""
+    TESTEXT=""
+}
+
+inform() {
+    echo "[${TESTNAME}] Creating ${TESTFMT} (.${TESTEXT}) test images..."
+}
+
+# OPAQUE / GRAY_OPAQUE
+start "OPAQUE" "-alpha off"
+for rawfmt in $FMT_OPAQUE $FMT_BINARY $FMT_ALPHA; do
+    TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
+    for pat in $PAT_opaque; do
+        make_images "$pat"
+    done
+done
+
+start "GRAY-OPAQUE" "-alpha off -colorspace Gray"
+for rawfmt in $FMT_GRAY_OPAQUE $FMT_GRAY_BINARY $FMT_GRAY_ALPHA; do
+    TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
+    for pat in $PAT_gray_opaque; do
+        make_images "$pat"
+    done
+done
+
+# BINARY / GRAY_BINARY
+start "BINARY" "-alpha on"
+for rawfmt in $FMT_BINARY $FMT_ALPHA; do
+    TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
+    for pat in $PAT_binary; do
+        make_images "$pat"
+    done
+done
+
+start "GRAY-BINARY" "-alpha on -colorspace Gray"
+for rawfmt in $FMT_GRAY_BINARY $FMT_GRAY_ALPHA; do
+    TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
+    for pat in $PAT_gray_binary; do
+        make_images "$pat"
+    done
+done
+
+# ALPHA / GRAY_ALPHA
+start "ALPHA" "-alpha on"
+for rawfmt in $FMT_ALPHA; do
+    TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
+    for alpha in 7F F0; do
+        TESTALPHA=$alpha
+        for pat in $PAT_alpha; do
+            make_images "$pat"
+        done
+    done
+done
+
+start "GRAY-ALPHA" "-alpha on -colorspace Gray"
+for rawfmt in $FMT_GRAY_ALPHA; do
+    TESTFMT=${rawfmt%:*}; TESTEXT=${rawfmt#*:}; inform
+    for alpha in 7F F0; do
+        TESTALPHA=$alpha
+        for pat in $PAT_gray_alpha; do
+            make_images "$pat"
+        done
+    done
+done
diff --git a/kivy/tools/kviewer.py b/kivy/tools/kviewer.py
new file mode 100644
index 0000000..681e5e6
--- /dev/null
+++ b/kivy/tools/kviewer.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+'''
+KViewer
+=======
+
+KViewer, for KV-Viewer, is a simple tool allowing you to dynamically display
+a KV file, taking its changes into account (thanks to watchdog). The
+idea is to facilitate design using the KV language. It's somewhat related to
+the KivyCatalog demo, except it uses an on-disc file, allowing the user to use
+any editor.
+
+You can use the script as follows::
+
+    python kviewer.py ./test.kv
+
+This will display the test.kv and automatically update the display when the
+file changes.
+
+.. note: This scripts uses watchdog to listen for file changes. To install
+   watchdog::
+
+   pip install watchdog
+
+'''
+
+from sys import argv
+from kivy.lang import Builder
+from kivy.app import App
+from kivy.core.window import Window
+from kivy.clock import Clock, mainthread
+from kivy.uix.label import Label
+
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from os.path import dirname, basename, join
+
+
+if len(argv) != 2:
+    print('usage: %s filename.kv' % argv[0])
+    exit(1)
+
+
+PATH = dirname(argv[1])
+TARGET = basename(argv[1])
+
+
+class KvHandler(FileSystemEventHandler):
+    def __init__(self, callback, target, **kwargs):
+        super(KvHandler, self).__init__(**kwargs)
+        self.callback = callback
+        self.target = target
+
+    def on_any_event(self, event):
+        if basename(event.src_path) == self.target:
+            self.callback()
+
+
+class KvViewerApp(App):
+    def build(self):
+        o = Observer()
+        o.schedule(KvHandler(self.update, TARGET), PATH)
+        o.start()
+        Clock.schedule_once(self.update, 1)
+        return super(KvViewerApp, self).build()
+
+    @mainthread
+    def update(self, *args):
+        Builder.unload_file(join(PATH, TARGET))
+        for w in Window.children[:]:
+            Window.remove_widget(w)
+        try:
+            Window.add_widget(Builder.load_file(join(PATH, TARGET)))
+        except Exception as e:
+            Window.add_widget(Label(text=(
+                e.message if getattr(e, r'message', None) else str(e)
+            )))
+
+
+if __name__ == '__main__':
+    KvViewerApp().run()
diff --git a/kivy/tools/packaging/__init__.py b/kivy/tools/packaging/__init__.py
new file mode 100644
index 0000000..895973c
--- /dev/null
+++ b/kivy/tools/packaging/__init__.py
@@ -0,0 +1,12 @@
+'''
+Packaging
+=========
+
+This module contains `PyInstaller <http://www.pyinstaller.org/>`_ hooks in
+order to assist in the process of building binary packages. PyInstaller allows
+you to produce stand-alone, self-contained executables of your Kivy app for
+Windows, Linux and Mac.
+
+For more information, please see the `PyInstaller website
+<http://www.pyinstaller.org/>`_
+'''
diff --git a/kivy/tools/packaging/__pycache__/__init__.cpython-310.pyc b/kivy/tools/packaging/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..c8c0042
Binary files /dev/null and b/kivy/tools/packaging/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/tools/packaging/__pycache__/cython_cfg.cpython-310.pyc b/kivy/tools/packaging/__pycache__/cython_cfg.cpython-310.pyc
new file mode 100644
index 0000000..97a1a8e
Binary files /dev/null and b/kivy/tools/packaging/__pycache__/cython_cfg.cpython-310.pyc differ
diff --git a/kivy/tools/packaging/__pycache__/factory.cpython-310.pyc b/kivy/tools/packaging/__pycache__/factory.cpython-310.pyc
new file mode 100644
index 0000000..bc43ffc
Binary files /dev/null and b/kivy/tools/packaging/__pycache__/factory.cpython-310.pyc differ
diff --git a/kivy/tools/packaging/cython_cfg.py b/kivy/tools/packaging/cython_cfg.py
new file mode 100644
index 0000000..138b15d
--- /dev/null
+++ b/kivy/tools/packaging/cython_cfg.py
@@ -0,0 +1,82 @@
+import configparser
+from os.path import join, dirname
+import textwrap
+
+__all__ = ('get_cython_versions', 'get_cython_msg')
+
+
+def get_cython_versions(setup_cfg=''):
+    _cython_config = configparser.ConfigParser()
+    if setup_cfg:
+        _cython_config.read(setup_cfg)
+    else:
+        _cython_config.read(
+            join(dirname(__file__), '..', '..', '..', 'setup.cfg'))
+
+    cython_min = _cython_config['kivy']['cython_min']
+    cython_max = _cython_config['kivy']['cython_max']
+    cython_unsupported = _cython_config['kivy']['cython_exclude'].split(',')
+    # ref https://github.com/cython/cython/issues/1968
+
+    cython_requires = (
+        'cython>={min_version},<={max_version},{exclusion}'.format(
+            min_version=cython_min,
+            max_version=cython_max,
+            exclusion=','.join('!=%s' % excl for excl in cython_unsupported),
+        )
+    )
+
+    return cython_requires, cython_min, cython_max, cython_unsupported
+
+
+def get_cython_msg():
+    cython_requires, cython_min, cython_max, cython_unsupported = \
+        get_cython_versions()
+    cython_unsupported_append = '''
+
+    Please note that the following versions of Cython are not supported
+    at all: {}'''.format(', '.join(map(str, cython_unsupported)))
+
+    cython_min_msg = textwrap.dedent('''
+    This version of Cython is not compatible with Kivy. Please upgrade to
+    at least version {0}, preferably the newest supported version {1}.
+
+    If your platform provides a Cython package, make sure you have upgraded
+    to the newest version. If the newest version available is still too low,
+    please remove it and install the newest supported Cython via pip:
+
+        pip install -I "{3}"{2}
+    '''.format(cython_min, cython_max,
+               cython_unsupported_append if cython_unsupported else '',
+               cython_requires))
+
+    cython_max_msg = textwrap.dedent('''
+    This version of Cython is untested with Kivy. While this version may
+    work perfectly fine, it is possible that you may experience issues.
+    Please downgrade to a supported version, or update cython_max in
+    setup.cfg to your version of Cython. It is best to use the newest
+    supported version, {1}, but the minimum supported version is {0}.
+
+    If your platform provides a Cython package, check if you can downgrade
+    to a supported version. Otherwise, uninstall the platform package and
+    install Cython via pip:
+
+        pip install -I "{3}"{2}
+    '''.format(cython_min, cython_max,
+               cython_unsupported_append if cython_unsupported else '',
+               cython_requires))
+
+    cython_unsupported_msg = textwrap.dedent('''
+    This version of Cython suffers from known bugs and is unsupported.
+    Please install the newest supported version, {1}, if possible, but
+    the minimum supported version is {0}.
+
+    If your platform provides a Cython package, check if you can install
+    a supported version. Otherwise, uninstall the platform package and
+    install Cython via pip:
+
+        pip install -I "{3}"{2}
+    '''.format(cython_min, cython_max, cython_unsupported_append,
+               cython_requires))
+
+    return cython_min_msg, cython_max_msg, cython_unsupported_msg
diff --git a/kivy/tools/packaging/factory.py b/kivy/tools/packaging/factory.py
new file mode 100644
index 0000000..779ae5e
--- /dev/null
+++ b/kivy/tools/packaging/factory.py
@@ -0,0 +1,103 @@
+from __future__ import print_function
+
+__all__ = ('FactoryBuild', )
+
+from distutils.cmd import Command
+import fnmatch
+import os
+import kivy
+
+ignore_list = (
+    'kivy.lib',
+    'kivy.input.providers',
+    'kivy.input.postproc',
+    'kivy.modules',
+    'kivy.tools',
+    'kivy.parser',
+    'kivy.tests',
+)
+
+
+class FactoryBuild(Command):
+    description = 'Build the factory relation file (for factory.py)'
+    user_options = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        print('--------------------------------------------')
+        print('Building factory relation file')
+        print('--------------------------------------------')
+
+        root_dir = os.path.dirname(kivy.__file__)
+        filename = os.path.join(root_dir, 'factory_registers.py')
+        with open(filename, 'w') as fd:
+            fd.close()
+
+        # ensure we don't have any thing like doc running
+        symbols = []
+        for root, dirnames, filenames in os.walk(root_dir):
+            if not root.startswith(root_dir):
+                raise Exception('Directory should start with the kivy'
+                                'directory')
+            root = 'kivy' + root[len(root_dir):].replace(os.path.sep, '.')
+            for filename in fnmatch.filter(filenames, '*.[ps][yo]'):
+                module = '%s.%s' % (root, filename[:-3])
+
+                # check ignore list first
+                ignore = False
+                for ignore in ignore_list:
+                    if module.startswith(ignore):
+                        ignore = True
+                        break
+                if ignore:
+                    # print('<<< ignored (ignore list)')
+                    continue
+
+                # special case, core providers
+                if root.startswith('kivy.core.'):
+                    if not root.endswith('__init__.py'):
+                        # print('<<< ignored (not a __init__.py)')
+                        continue
+
+                print('>>>', module, '::', end=' ')
+
+                try:
+                    m = __import__(name=module, fromlist='.')
+                except Exception as e:
+                    print()
+                    print('ERROR:', e)
+                    continue
+                if not hasattr(m, '__all__'):
+                    print()
+                    continue
+                for symbol in getattr(m, '__all__'):
+                    if symbol.startswith('_'):
+                        continue
+                    attr = getattr(m, symbol)
+                    if type(attr) not in (type, type):
+                        continue
+                    symbols.append((symbol, module))
+                    print(symbol, end=' ')
+                print()
+
+        print()
+        print('--------------------------------------------')
+        print('Found %d symbols, generating file' % len(symbols))
+        print('--------------------------------------------')
+
+        filename = os.path.join(root_dir, 'factory_registers.py')
+        with open(filename, 'w') as fd:
+            fd.write('# Auto-generated file by setup.py build_factory\n')
+            fd.write('\n')
+            fd.write('from kivy.factory import Factory\n')
+            fd.write('\n')
+            fd.write('r = Factory.register\n')
+            for x in symbols:
+                fd.write("r('%s', module='%s')\n" % x)
+
+        print('File written at', filename)
diff --git a/kivy/tools/packaging/pyinstaller_hooks/__init__.py b/kivy/tools/packaging/pyinstaller_hooks/__init__.py
new file mode 100644
index 0000000..dc81d2b
--- /dev/null
+++ b/kivy/tools/packaging/pyinstaller_hooks/__init__.py
@@ -0,0 +1,373 @@
+'''
+Pyinstaller hooks
+=================
+
+Module that exports pyinstaller related methods and parameters.
+
+Hooks
+-----
+
+PyInstaller comes with a default hook for kivy that lists the indirectly
+imported modules that pyinstaller would not find on its own using
+:func:`get_deps_all`. :func:`hookspath` returns the path to an alternate kivy
+hook, ``kivy/tools/packaging/pyinstaller_hooks/kivy-hook.py`` that does not
+add these dependencies to its list of hidden imports and they have to be
+explicitly included instead.
+
+One can overwrite the default hook by providing on the command line the
+``--additional-hooks-dir=HOOKSPATH`` option. Because although the default
+hook will still run, the `important global variables
+<https://pythonhosted.org/PyInstaller/#hook-global-variables>`_, e.g.
+``excludedimports`` and ``hiddenimports`` will be overwritten by the
+new hook, if set there.
+
+Additionally, one can add a hook to be run after the default hook by
+passing e.g. ``hookspath=[HOOKSPATH]`` to the ``Analysis`` class. In both
+cases, ``HOOKSPATH`` is the path to a directory containing a file named
+``hook-kivy.py`` that is the pyinstaller hook for kivy to be processed
+after the default hook.
+
+hiddenimports
+-------------
+
+When a module is imported indirectly, e.g. with ``__import__``, pyinstaller
+won't know about it and the module has to be added through ``hiddenimports``.
+
+``hiddenimports`` and other hook variables can be specified within a hook as
+described above. Also, these variable can be passed to ``Analysis`` and their
+values are then appended to the hook's values for these variables.
+
+Most of kivy's core modules, e.g. video are imported indirectly and therefore
+need to be added in hiddenimports. The default PyInstaller hook adds all the
+providers. To overwrite, a modified kivy-hook similar to the default hook, such
+as :func:`hookspath` that only imports the desired modules can be added. One
+then uses :func:`get_deps_minimal` or :func:`get_deps_all` to get the list of
+modules and adds them manually in a modified hook or passes them to
+``Analysis`` in the spec file.
+
+Hook generator
+--------------
+
+:mod:`pyinstaller_hooks` includes a tool to generate a hook which lists
+all the provider modules in a list so that one can manually comment out
+the providers not to be included. To use, do::
+
+    python -m kivy.tools.packaging.pyinstaller_hooks hook filename
+
+``filename`` is the name and path of the hook file to create. If ``filename``
+is not provided the hook is printed to the terminal.
+'''
+
+import os
+import sys
+import pkgutil
+import logging
+from os.path import dirname, join
+import importlib
+import subprocess
+import re
+import glob
+
+import kivy
+try:
+    from kivy import deps as old_deps
+except ImportError:
+    old_deps = None
+try:
+    import kivy_deps
+except ImportError:
+    kivy_deps = None
+from kivy.factory import Factory
+from PyInstaller.depend import bindepend
+
+from os import environ
+if 'KIVY_DOC' not in environ:
+    from PyInstaller.utils.hooks import collect_submodules
+
+    curdir = dirname(__file__)
+
+    kivy_modules = [
+        'xml.etree.cElementTree',
+        'kivy.core.gl',
+        'kivy.weakmethod',
+        'kivy.core.window.window_info',
+    ] + collect_submodules('kivy.graphics')
+    '''List of kivy modules that are always needed as hiddenimports of
+    pyinstaller.
+    '''
+
+    excludedimports = ['tkinter', '_tkinter', 'twisted']
+    '''List of excludedimports that should always be excluded from
+    pyinstaller.
+    '''
+
+    datas = [
+        (kivy.kivy_data_dir,
+         os.path.join('kivy_install', os.path.basename(kivy.kivy_data_dir))),
+        (kivy.kivy_modules_dir,
+         os.path.join('kivy_install', os.path.basename(kivy.kivy_modules_dir)))
+    ]
+'''List of data to be included by pyinstaller.
+'''
+
+
+def runtime_hooks():
+    '''Returns a list with the runtime hooks for kivy. It can be used with
+    ``runtime_hooks=runtime_hooks()`` in the spec file. Pyinstaller comes
+    preinstalled with this hook.
+    '''
+    return [join(curdir, 'pyi_rth_kivy.py')]
+
+
+def hookspath():
+    '''Returns a list with the directory that contains the alternate (not
+    the default included with pyinstaller) pyinstaller hook for kivy,
+    ``kivy/tools/packaging/pyinstaller_hooks/kivy-hook.py``. It is
+    typically used with ``hookspath=hookspath()`` in the spec
+    file.
+
+    The default pyinstaller hook returns all the core providers used using
+    :func:`get_deps_minimal` to add to its list of hidden imports. This
+    alternate hook only included the essential modules and leaves the core
+    providers to be included additionally with :func:`get_deps_minimal`
+    or :func:`get_deps_all`.
+    '''
+    return [curdir]
+
+
+def get_hooks():
+    '''Returns the dict for the spec ``hookspath`` and ``runtime_hooks``
+    values.
+    '''
+    return {'hookspath': hookspath(), 'runtime_hooks': runtime_hooks()}
+
+
+def get_deps_minimal(exclude_ignored=True, **kwargs):
+    '''Returns Kivy hidden modules as well as excluded modules to be used
+    with ``Analysis``.
+
+    The function takes core modules as keyword arguments and their value
+    indicates which of the providers to include/exclude from the compiled app.
+
+    The possible keyword names are ``audio, camera, clipboard, image, spelling,
+    text, video, and window``. Their values can be:
+
+        ``True``: Include current provider
+            The providers imported when the core module is
+            loaded on this system are added to hidden imports. This is the
+            default if the keyword name is not specified.
+        ``None``: Exclude
+            Don't return this core module at all.
+        ``A string or list of strings``: Providers to include
+            Each string is the name of a provider for this module to be
+            included.
+
+    For example, ``get_deps_minimal(video=None, window=True,
+    audio=['gstplayer', 'ffpyplayer'], spelling='enchant')`` will exclude all
+    the video providers, will include the gstreamer and ffpyplayer providers
+    for audio, will include the enchant provider for spelling, and will use the
+    current default provider for ``window``.
+
+    ``exclude_ignored``, if ``True`` (the default), if the value for a core
+    library is ``None``, then if ``exclude_ignored`` is True, not only will the
+    library not be included in the hiddenimports but it'll also added to the
+    excluded imports to prevent it being included accidentally by pyinstaller.
+
+    :returns:
+
+        A dict with three keys, ``hiddenimports``, ``excludes``, and
+        ``binaries``. Their values are a list of the corresponding modules to
+        include/exclude. This can be passed directly to `Analysis`` with
+        e.g. ::
+
+            a = Analysis(['..\\kivy\\examples\\demo\\touchtracer\\main.py'],
+                        ...
+                         hookspath=hookspath(),
+                         runtime_hooks=[],
+                         win_no_prefer_redirects=False,
+                         win_private_assemblies=False,
+                         cipher=block_cipher,
+                         **get_deps_minimal(video=None, audio=None))
+    '''
+    core_mods = ['audio', 'camera', 'clipboard', 'image', 'spelling', 'text',
+                 'video', 'window']
+    mods = kivy_modules[:]
+    excludes = excludedimports[:]
+
+    for mod_name, val in kwargs.items():
+        if mod_name not in core_mods:
+            raise KeyError('{} not found in {}'.format(mod_name, core_mods))
+
+        full_name = 'kivy.core.{}'.format(mod_name)
+        if not val:
+            core_mods.remove(mod_name)
+            if exclude_ignored:
+                excludes.extend(collect_submodules(full_name))
+            continue
+        if val is True:
+            continue
+        core_mods.remove(mod_name)
+
+        mods.append(full_name)
+        single_mod = False
+        if isinstance(val, (str, bytes)):
+            single_mod = True
+            mods.append('kivy.core.{0}.{0}_{1}'.format(mod_name, val))
+        if not single_mod:
+            for v in val:
+                mods.append('kivy.core.{0}.{0}_{1}'.format(mod_name, v))
+
+    for mod_name in core_mods:  # process remaining default modules
+        full_name = 'kivy.core.{}'.format(mod_name)
+        mods.append(full_name)
+        m = importlib.import_module(full_name)
+
+        if mod_name == 'clipboard' and m.CutBuffer:
+            mods.append(m.CutBuffer.__module__)
+        if hasattr(m, mod_name.capitalize()):  # e.g. video -> Video
+            val = getattr(m, mod_name.capitalize())
+            if val:
+                mods.append(getattr(val, '__module__'))
+
+        if hasattr(m, 'libs_loaded') and m.libs_loaded:
+            for name in m.libs_loaded:
+                mods.append('kivy.core.{}.{}'.format(mod_name, name))
+
+    mods = sorted(set(mods))
+
+    binaries = []
+    if any('gstplayer' in m for m in mods):
+        binaries = _find_gst_binaries()
+    elif exclude_ignored:
+        excludes.append('kivy.lib.gstplayer')
+
+    return {
+        'hiddenimports': mods,
+        'excludes': excludes,
+        'binaries': binaries,
+    }
+
+
+def get_deps_all():
+    '''Similar to :func:`get_deps_minimal`, but this returns all the
+    kivy modules that can indirectly imported. Which includes all
+    the possible kivy providers.
+
+    This can be used to get a list of all the possible providers
+    which can then manually be included/excluded by commenting out elements
+    in the list instead of passing on all the items. See module description.
+
+    :returns:
+
+        A dict with three keys, ``hiddenimports``, ``excludes``, and
+        ``binaries``. Their values are a list of the corresponding modules to
+        include/exclude. This can be passed directly to `Analysis`` with
+        e.g. ::
+
+            a = Analysis(['..\\kivy\\examples\\demo\\touchtracer\\main.py'],
+                        ...
+                         **get_deps_all())
+    '''
+    return {
+        'binaries': _find_gst_binaries(),
+        'hiddenimports': sorted(set(kivy_modules +
+                                    collect_submodules('kivy.core'))),
+        'excludes': []}
+
+
+def get_factory_modules():
+    '''Returns a list of all the modules registered in the kivy factory.
+    '''
+    mods = [x.get('module', None) for x in Factory.classes.values()]
+    return [m for m in mods if m]
+
+
+def add_dep_paths():
+    '''Should be called by the hook. It adds the paths with the binary
+    dependencies to the system path so that pyinstaller can find the binaries
+    during its crawling stage.
+    '''
+    paths = []
+    if old_deps is not None:
+        for importer, modname, ispkg in pkgutil.iter_modules(
+                old_deps.__path__):
+            if not ispkg:
+                continue
+            try:
+                mod = importer.find_module(modname).load_module(modname)
+            except ImportError as e:
+                logging.warn(
+                    "deps: Error importing dependency: {}".format(str(e)))
+                continue
+
+            if hasattr(mod, 'dep_bins'):
+                paths.extend(mod.dep_bins)
+    sys.path.extend(paths)
+
+    if kivy_deps is None:
+        return
+
+    paths = []
+    for importer, modname, ispkg in pkgutil.iter_modules(kivy_deps.__path__):
+        if not ispkg:
+            continue
+        try:
+            mod = importer.find_module(modname).load_module(modname)
+        except ImportError as e:
+            logging.warn("deps: Error importing dependency: {}".format(str(e)))
+            continue
+
+        if hasattr(mod, 'dep_bins'):
+            paths.extend(mod.dep_bins)
+    sys.path.extend(paths)
+
+
+def _find_gst_plugin_path():
+    '''Returns a list of directories to search for GStreamer plugins.
+    '''
+    if 'GST_PLUGIN_PATH' in environ:
+        return [
+            os.path.abspath(os.path.expanduser(path))
+            for path in environ['GST_PLUGIN_PATH'].split(os.pathsep)
+        ]
+
+    try:
+        p = subprocess.Popen(
+            ['gst-inspect-1.0', 'coreelements'],
+            stdout=subprocess.PIPE, universal_newlines=True)
+    except:
+        return []
+    (stdoutdata, stderrdata) = p.communicate()
+
+    match = re.search(r'\s+(\S+libgstcoreelements\.\S+)', stdoutdata)
+
+    if not match:
+        return []
+
+    return [os.path.dirname(match.group(1))]
+
+
+def _find_gst_binaries():
+    '''Returns a list of GStreamer plugins and libraries to pass as the
+    ``binaries`` argument of ``Analysis``.
+    '''
+    gst_plugin_path = _find_gst_plugin_path()
+
+    plugin_filepaths = []
+    for plugin_dir in gst_plugin_path:
+        plugin_filepaths.extend(
+            glob.glob(os.path.join(plugin_dir, 'libgst*')))
+    if len(plugin_filepaths) == 0:
+        logging.warn('Could not find GStreamer plugins. ' +
+                     'Possible solution: set GST_PLUGIN_PATH')
+        return []
+
+    lib_filepaths = set()
+    for plugin_filepath in plugin_filepaths:
+        plugin_deps = bindepend.selectImports(plugin_filepath)
+        lib_filepaths.update([path for _, path in plugin_deps])
+
+    plugin_binaries = [(f, 'gst-plugins') for f in plugin_filepaths]
+    lib_binaries = [(f, '.') for f in lib_filepaths]
+
+    return plugin_binaries + lib_binaries
diff --git a/kivy/tools/packaging/pyinstaller_hooks/__main__.py b/kivy/tools/packaging/pyinstaller_hooks/__main__.py
new file mode 100644
index 0000000..e1eac14
--- /dev/null
+++ b/kivy/tools/packaging/pyinstaller_hooks/__main__.py
@@ -0,0 +1,29 @@
+from kivy.tools.packaging.pyinstaller_hooks import get_deps_all
+import sys
+from os.path import dirname, join
+
+args = sys.argv[1:]
+if args and args[0] == 'hook':
+    with open(join(dirname(__file__), 'hook-kivy.py')) as fh:
+        src = fh.read()
+
+    formatted_lines = []
+    lines = get_deps_all()['hiddenimports']
+
+    for i, line in enumerate(lines):
+        if i and line[:line.rfind('.')] != \
+                 lines[i - 1][:lines[i - 1].rfind('.')]:
+            formatted_lines.append('\n')
+
+        if i == len(lines) - 1:
+            formatted_lines.append("    '{}'".format(line))
+        else:
+            formatted_lines.append("    '{}',\n".format(line))
+    lines = formatted_lines
+
+    lines = '{}\n\nhiddenimports += [\n{}\n]\n'.format(src, ''.join(lines))
+    if len(args) > 1:
+        with open(args[1], 'w') as fh:
+            fh.write(lines)
+    else:
+        print(lines)
diff --git a/kivy/tools/packaging/pyinstaller_hooks/__pycache__/__init__.cpython-310.pyc b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..0f88fcd
Binary files /dev/null and b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/tools/packaging/pyinstaller_hooks/__pycache__/__main__.cpython-310.pyc b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/__main__.cpython-310.pyc
new file mode 100644
index 0000000..e9fb0e1
Binary files /dev/null and b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/__main__.cpython-310.pyc differ
diff --git a/kivy/tools/packaging/pyinstaller_hooks/__pycache__/hook-kivy.cpython-310.pyc b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/hook-kivy.cpython-310.pyc
new file mode 100644
index 0000000..fa0810a
Binary files /dev/null and b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/hook-kivy.cpython-310.pyc differ
diff --git a/kivy/tools/packaging/pyinstaller_hooks/__pycache__/pyi_rth_kivy.cpython-310.pyc b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/pyi_rth_kivy.cpython-310.pyc
new file mode 100644
index 0000000..84af32e
Binary files /dev/null and b/kivy/tools/packaging/pyinstaller_hooks/__pycache__/pyi_rth_kivy.cpython-310.pyc differ
diff --git a/kivy/tools/packaging/pyinstaller_hooks/hook-kivy.py b/kivy/tools/packaging/pyinstaller_hooks/hook-kivy.py
new file mode 100644
index 0000000..9228607
--- /dev/null
+++ b/kivy/tools/packaging/pyinstaller_hooks/hook-kivy.py
@@ -0,0 +1,9 @@
+from kivy.tools.packaging.pyinstaller_hooks import (
+    add_dep_paths, excludedimports, datas, get_deps_all,
+    get_factory_modules, kivy_modules)
+
+add_dep_paths()
+
+hiddenimports = []  # get_deps_all()['hiddenimports']
+hiddenimports = list(set(
+    get_factory_modules() + kivy_modules + hiddenimports))
diff --git a/kivy/tools/packaging/pyinstaller_hooks/pyi_rth_kivy.py b/kivy/tools/packaging/pyinstaller_hooks/pyi_rth_kivy.py
new file mode 100644
index 0000000..0b5e36b
--- /dev/null
+++ b/kivy/tools/packaging/pyinstaller_hooks/pyi_rth_kivy.py
@@ -0,0 +1,17 @@
+import os
+import sys
+
+root = os.path.join(sys._MEIPASS, 'kivy_install')
+
+os.environ['KIVY_DATA_DIR'] = os.path.join(root, 'data')
+os.environ['KIVY_MODULES_DIR'] = os.path.join(root, 'modules')
+os.environ['GST_PLUGIN_PATH'] = '{}{}{}'.format(
+    sys._MEIPASS, os.pathsep, os.path.join(sys._MEIPASS, 'gst-plugins'))
+os.environ['GST_REGISTRY'] = os.path.join(sys._MEIPASS, 'registry.bin')
+
+sys.path += [os.path.join(root, '_libs')]
+
+if sys.platform == 'darwin':
+    sitepackages = os.path.join(sys._MEIPASS, 'sitepackages')
+    sys.path += [sitepackages, os.path.join(sitepackages, 'gst-0.10')]
+    os.putenv('GST_REGISTRY_FORK', 'no')
diff --git a/kivy/tools/pep8checker/__pycache__/pep8.cpython-310.pyc b/kivy/tools/pep8checker/__pycache__/pep8.cpython-310.pyc
new file mode 100644
index 0000000..2f8dc01
Binary files /dev/null and b/kivy/tools/pep8checker/__pycache__/pep8.cpython-310.pyc differ
diff --git a/kivy/tools/pep8checker/__pycache__/pep8kivy.cpython-310.pyc b/kivy/tools/pep8checker/__pycache__/pep8kivy.cpython-310.pyc
new file mode 100644
index 0000000..8db5954
Binary files /dev/null and b/kivy/tools/pep8checker/__pycache__/pep8kivy.cpython-310.pyc differ
diff --git a/kivy/tools/pep8checker/pep8.py b/kivy/tools/pep8checker/pep8.py
new file mode 100644
index 0000000..c19d042
--- /dev/null
+++ b/kivy/tools/pep8checker/pep8.py
@@ -0,0 +1,2316 @@
+#!/usr/bin/env python
+# pycodestyle.py - Check Python source code formatting, according to PEP 8
+#
+# Copyright (C) 2006-2009 Johann C. Rocholl <johann@rocholl.net>
+# Copyright (C) 2009-2014 Florent Xicluna <florent.xicluna@gmail.com>
+# Copyright (C) 2014-2016 Ian Lee <ianlee1521@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+r"""
+Check Python source code formatting, according to PEP 8.
+
+For usage and a list of options, try this:
+$ python pycodestyle.py -h
+
+This program and its regression test suite live here:
+https://github.com/pycqa/pycodestyle
+
+Groups of errors and warnings:
+E errors
+W warnings
+100 indentation
+200 whitespace
+300 blank lines
+400 imports
+500 line length
+600 deprecation
+700 statements
+900 syntax error
+"""
+from __future__ import with_statement
+
+import inspect
+import keyword
+import os
+import re
+import sys
+import time
+import tokenize
+import warnings
+
+from fnmatch import fnmatch
+from optparse import OptionParser
+
+try:
+    from configparser import RawConfigParser
+    from io import TextIOWrapper
+except ImportError:
+    from ConfigParser import RawConfigParser
+
+__version__ = '2.2.0'
+
+DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__,.tox'
+DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704,W503'
+try:
+    if sys.platform == 'win32':
+        USER_CONFIG = os.path.expanduser(r'~\.pycodestyle')
+    else:
+        USER_CONFIG = os.path.join(
+            os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'),
+            'pycodestyle'
+        )
+except ImportError:
+    USER_CONFIG = None
+
+PROJECT_CONFIG = ('setup.cfg', 'tox.ini')
+TESTSUITE_PATH = os.path.join(os.path.dirname(__file__), 'testsuite')
+MAX_LINE_LENGTH = 79
+REPORT_FORMAT = {
+    'default': '%(path)s:%(row)d:%(col)d: %(code)s %(text)s',
+    'pylint': '%(path)s:%(row)d: [%(code)s] %(text)s',
+}
+
+PyCF_ONLY_AST = 1024
+SINGLETONS = frozenset(['False', 'None', 'True'])
+KEYWORDS = frozenset(keyword.kwlist + ['print']) - SINGLETONS
+UNARY_OPERATORS = frozenset(['>>', '**', '*', '+', '-'])
+ARITHMETIC_OP = frozenset(['**', '*', '/', '//', '+', '-'])
+WS_OPTIONAL_OPERATORS = ARITHMETIC_OP.union(['^', '&', '|', '<<', '>>', '%'])
+WS_NEEDED_OPERATORS = frozenset([
+    '**=', '*=', '/=', '//=', '+=', '-=', '!=', '<>', '<', '>',
+    '%=', '^=', '&=', '|=', '==', '<=', '>=', '<<=', '>>=', '='])
+WHITESPACE = frozenset(' \t')
+NEWLINE = frozenset([tokenize.NL, tokenize.NEWLINE])
+SKIP_TOKENS = NEWLINE.union([tokenize.INDENT, tokenize.DEDENT])
+# ERRORTOKEN is triggered by backticks in Python 3
+SKIP_COMMENTS = SKIP_TOKENS.union([tokenize.COMMENT, tokenize.ERRORTOKEN])
+BENCHMARK_KEYS = ['directories', 'files', 'logical lines', 'physical lines']
+
+INDENT_REGEX = re.compile(r'([ \t]*)')
+RAISE_COMMA_REGEX = re.compile(r'raise\s+\w+\s*,')
+RERAISE_COMMA_REGEX = re.compile(r'raise\s+\w+\s*,.*,\s*\w+\s*$')
+ERRORCODE_REGEX = re.compile(r'\b[A-Z]\d{3}\b')
+DOCSTRING_REGEX = re.compile(r'u?r?["\']')
+EXTRANEOUS_WHITESPACE_REGEX = re.compile(r'[[({] | []}),;:]')
+WHITESPACE_AFTER_COMMA_REGEX = re.compile(r'[,;:]\s*(?:  |\t)')
+COMPARE_SINGLETON_REGEX = re.compile(r'(\bNone|\bFalse|\bTrue)?\s*([=!]=)'
+                                     r'\s*(?(1)|(None|False|True))\b')
+COMPARE_NEGATIVE_REGEX = re.compile(r'\b(not)\s+[^][)(}{ ]+\s+(in|is)\s')
+COMPARE_TYPE_REGEX = re.compile(r'(?:[=!]=|is(?:\s+not)?)\s*type(?:s.\w+Type'
+                                r'|\s*\(\s*([^)]*[^ )])\s*\))')
+KEYWORD_REGEX = re.compile(r'(\s*)\b(?:%s)\b(\s*)' % r'|'.join(KEYWORDS))
+OPERATOR_REGEX = re.compile(r'(?:[^,\s])(\s*)(?:[-+*/|!<=>%&^]+)(\s*)')
+LAMBDA_REGEX = re.compile(r'\blambda\b')
+HUNK_REGEX = re.compile(r'^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@.*$')
+
+# Work around Python < 2.6 behaviour, which does not generate NL after
+# a comment which is on a line by itself.
+COMMENT_WITH_NL = tokenize.generate_tokens(['#\n'].pop).send(None)[1] == '#\n'
+
+
+##############################################################################
+# Plugins (check functions) for physical lines
+##############################################################################
+
+
+def tabs_or_spaces(physical_line, indent_char):
+    r"""Never mix tabs and spaces.
+
+    The most popular way of indenting Python is with spaces only.  The
+    second-most popular way is with tabs only.  Code indented with a mixture
+    of tabs and spaces should be converted to using spaces exclusively.  When
+    invoking the Python command line interpreter with the -t option, it issues
+    warnings about code that illegally mixes tabs and spaces.  When using -tt
+    these warnings become errors.  These options are highly recommended!
+
+    Okay: if a == 0:\n        a = 1\n        b = 1
+    E101: if a == 0:\n        a = 1\n\tb = 1
+    """
+    indent = INDENT_REGEX.match(physical_line).group(1)
+    for offset, char in enumerate(indent):
+        if char != indent_char:
+            return offset, "E101 indentation contains mixed spaces and tabs"
+
+
+def tabs_obsolete(physical_line):
+    r"""For new projects, spaces-only are strongly recommended over tabs.
+
+    Okay: if True:\n    return
+    W191: if True:\n\treturn
+    """
+    indent = INDENT_REGEX.match(physical_line).group(1)
+    if '\t' in indent:
+        return indent.index('\t'), "W191 indentation contains tabs"
+
+
+def trailing_whitespace(physical_line):
+    r"""Trailing whitespace is superfluous.
+
+    The warning returned varies on whether the line itself is blank, for easier
+    filtering for those who want to indent their blank lines.
+
+    Okay: spam(1)\n#
+    W291: spam(1) \n#
+    W293: class Foo(object):\n    \n    bang = 12
+    """
+    physical_line = physical_line.rstrip('\n')    # chr(10), newline
+    physical_line = physical_line.rstrip('\r')    # chr(13), carriage return
+    physical_line = physical_line.rstrip('\x0c')  # chr(12), form feed, ^L
+    stripped = physical_line.rstrip(' \t\v')
+    if physical_line != stripped:
+        if stripped:
+            return len(stripped), "W291 trailing whitespace"
+        else:
+            return 0, "W293 blank line contains whitespace"
+
+
+def trailing_blank_lines(physical_line, lines, line_number, total_lines):
+    r"""Trailing blank lines are superfluous.
+
+    Okay: spam(1)
+    W391: spam(1)\n
+
+    However the last line should end with a new line (warning W292).
+    """
+    if line_number == total_lines:
+        stripped_last_line = physical_line.rstrip()
+        if not stripped_last_line:
+            return 0, "W391 blank line at end of file"
+        if stripped_last_line == physical_line:
+            return len(physical_line), "W292 no newline at end of file"
+
+
+def maximum_line_length(physical_line, max_line_length, multiline, noqa):
+    r"""Limit all lines to a maximum of 79 characters.
+
+    There are still many devices around that are limited to 80 character
+    lines; plus, limiting windows to 80 characters makes it possible to have
+    several windows side-by-side.  The default wrapping on such devices looks
+    ugly.  Therefore, please limit all lines to a maximum of 79 characters.
+    For flowing long blocks of text (docstrings or comments), limiting the
+    length to 72 characters is recommended.
+
+    Reports error E501.
+    """
+    line = physical_line.rstrip()
+    length = len(line)
+    if length > max_line_length and not noqa:
+        # Special case for long URLs in multi-line docstrings or comments,
+        # but still report the error when the 72 first chars are whitespaces.
+        chunks = line.split()
+        if ((len(chunks) == 1 and multiline) or
+            (len(chunks) == 2 and chunks[0] == '#')) and \
+                len(line) - len(chunks[-1]) < max_line_length - 7:
+            return
+        if hasattr(line, 'decode'):   # Python 2
+            # The line could contain multi-byte characters
+            try:
+                length = len(line.decode('utf-8'))
+            except UnicodeError:
+                pass
+        if length > max_line_length:
+            return (max_line_length, "E501 line too long "
+                    "(%d > %d characters)" % (length, max_line_length))
+
+
+##############################################################################
+# Plugins (check functions) for logical lines
+##############################################################################
+
+
+def blank_lines(logical_line, blank_lines, indent_level, line_number,
+                blank_before, previous_logical,
+                previous_unindented_logical_line, previous_indent_level,
+                lines):
+    r"""Separate top-level function and class definitions with two blank lines.
+
+    Method definitions inside a class are separated by a single blank line.
+
+    Extra blank lines may be used (sparingly) to separate groups of related
+    functions.  Blank lines may be omitted between a bunch of related
+    one-liners (e.g. a set of dummy implementations).
+
+    Use blank lines in functions, sparingly, to indicate logical sections.
+
+    Okay: def a():\n    pass\n\n\ndef b():\n    pass
+    Okay: def a():\n    pass\n\n\nasync def b():\n    pass
+    Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
+    Okay: default = 1\nfoo = 1
+    Okay: classify = 1\nfoo = 1
+
+    E301: class Foo:\n    b = 0\n    def bar():\n        pass
+    E302: def a():\n    pass\n\ndef b(n):\n    pass
+    E302: def a():\n    pass\n\nasync def b(n):\n    pass
+    E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
+    E303: def a():\n\n\n\n    pass
+    E304: @decorator\n\ndef a():\n    pass
+    E305: def a():\n    pass\na()
+    """
+    if line_number < 3 and not previous_logical:
+        return  # Don't expect blank lines before the first line
+    if previous_logical.startswith('@'):
+        if blank_lines:
+            yield 0, "E304 blank lines found after function decorator"
+    elif blank_lines > 2 or (indent_level and blank_lines == 2):
+        yield 0, "E303 too many blank lines (%d)" % blank_lines
+    elif logical_line.startswith(('def ', 'async def', 'class ', '@')):
+        if indent_level:
+            if not (blank_before or previous_indent_level < indent_level or
+                    DOCSTRING_REGEX.match(previous_logical)):
+                ancestor_level = indent_level
+                nested = False
+                # Search backwards for a def ancestor or tree root (top level).
+                for line in lines[line_number - 2::-1]:
+                    if line.strip() and expand_indent(line) < ancestor_level:
+                        ancestor_level = expand_indent(line)
+                        nested = line.lstrip().startswith('def ')
+                        if nested or ancestor_level == 0:
+                            break
+                if nested:
+                    yield 0, "E306 expected 1 blank line before a " \
+                        "nested definition, found 0"
+                else:
+                    yield 0, "E301 expected 1 blank line, found 0"
+        elif blank_before != 2:
+            yield 0, "E302 expected 2 blank lines, found %d" % blank_before
+    elif (logical_line and not indent_level and blank_before != 2 and
+          previous_unindented_logical_line.startswith(('def ', 'class '))):
+        yield 0, "E305 expected 2 blank lines after " \
+            "class or function definition, found %d" % blank_before
+
+
+def extraneous_whitespace(logical_line):
+    r"""Avoid extraneous whitespace.
+
+    Avoid extraneous whitespace in these situations:
+    - Immediately inside parentheses, brackets or braces.
+    - Immediately before a comma, semicolon, or colon.
+
+    Okay: spam(ham[1], {eggs: 2})
+    E201: spam( ham[1], {eggs: 2})
+    E201: spam(ham[ 1], {eggs: 2})
+    E201: spam(ham[1], { eggs: 2})
+    E202: spam(ham[1], {eggs: 2} )
+    E202: spam(ham[1 ], {eggs: 2})
+    E202: spam(ham[1], {eggs: 2 })
+
+    E203: if x == 4: print(x, y); x, y = y , x
+    E203: if x == 4: print(x, y); x, y = y, x
+    E203: if x == 4 : print(x, y); x, y = y, x
+    """
+    line = logical_line
+    for match in EXTRANEOUS_WHITESPACE_REGEX.finditer(line):
+        text = match.group()
+        char = text.strip()
+        found = match.start()
+        if text == char + ' ':
+            # assert char in '([{'
+            yield found + 1, "E201 whitespace after '%s'" % char
+        elif line[found - 1] != ',':
+            code = ('E202' if char in '}])' else 'E203')  # if char in ',;:'
+            yield found, "%s whitespace before '%s'" % (code, char)
+
+
+def whitespace_around_keywords(logical_line):
+    r"""Avoid extraneous whitespace around keywords.
+
+    Okay: True and False
+    E271: True and  False
+    E272: True  and False
+    E273: True and\tFalse
+    E274: True\tand False
+    """
+    for match in KEYWORD_REGEX.finditer(logical_line):
+        before, after = match.groups()
+
+        if '\t' in before:
+            yield match.start(1), "E274 tab before keyword"
+        elif len(before) > 1:
+            yield match.start(1), "E272 multiple spaces before keyword"
+
+        if '\t' in after:
+            yield match.start(2), "E273 tab after keyword"
+        elif len(after) > 1:
+            yield match.start(2), "E271 multiple spaces after keyword"
+
+
+def missing_whitespace_after_import_keyword(logical_line):
+    r"""Multiple imports in form from x import (a, b, c) should have space
+    between import statement and parenthesised name list.
+
+    Okay: from foo import (bar, baz)
+    E275: from foo import(bar, baz)
+    E275: from importable.module import(bar, baz)
+    """
+    line = logical_line
+    indicator = ' import('
+    if line.startswith('from '):
+        found = line.find(indicator)
+        if -1 < found:
+            pos = found + len(indicator) - 1
+            yield pos, "E275 missing whitespace after keyword"
+
+
+def missing_whitespace(logical_line):
+    r"""Each comma, semicolon or colon should be followed by whitespace.
+
+    Okay: [a, b]
+    Okay: (3,)
+    Okay: a[1:4]
+    Okay: a[:4]
+    Okay: a[1:]
+    Okay: a[1:4:2]
+    E231: ['a','b']
+    E231: foo(bar,baz)
+    E231: [{'a':'b'}]
+    """
+    line = logical_line
+    for index in range(len(line) - 1):
+        char = line[index]
+        if char in ',;:' and line[index + 1] not in WHITESPACE:
+            before = line[:index]
+            if char == ':' and before.count('[') > before.count(']') and \
+                    before.rfind('{') < before.rfind('['):
+                continue  # Slice syntax, no space required
+            if char == ',' and line[index + 1] == ')':
+                continue  # Allow tuple with only one element: (3,)
+            yield index, "E231 missing whitespace after '%s'" % char
+
+
+def indentation(logical_line, previous_logical, indent_char,
+                indent_level, previous_indent_level):
+    r"""Use 4 spaces per indentation level.
+
+    For really old code that you don't want to mess up, you can continue to
+    use 8-space tabs.
+
+    Okay: a = 1
+    Okay: if a == 0:\n    a = 1
+    E111:   a = 1
+    E114:   # a = 1
+
+    Okay: for item in items:\n    pass
+    E112: for item in items:\npass
+    E115: for item in items:\n# Hi\n    pass
+
+    Okay: a = 1\nb = 2
+    E113: a = 1\n    b = 2
+    E116: a = 1\n    # b = 2
+    """
+    c = 0 if logical_line else 3
+    tmpl = "E11%d %s" if logical_line else "E11%d %s (comment)"
+    if indent_level % 4:
+        yield 0, tmpl % (1 + c, "indentation is not a multiple of four")
+    indent_expect = previous_logical.endswith(':')
+    if indent_expect and indent_level <= previous_indent_level:
+        yield 0, tmpl % (2 + c, "expected an indented block")
+    elif not indent_expect and indent_level > previous_indent_level:
+        yield 0, tmpl % (3 + c, "unexpected indentation")
+
+
+def continued_indentation(logical_line, tokens, indent_level, hang_closing,
+                          indent_char, noqa, verbose):
+    r"""Continuation lines indentation.
+
+    Continuation lines should align wrapped elements either vertically
+    using Python's implicit line joining inside parentheses, brackets
+    and braces, or using a hanging indent.
+
+    When using a hanging indent these considerations should be applied:
+    - there should be no arguments on the first line, and
+    - further indentation should be used to clearly distinguish itself as a
+      continuation line.
+
+    Okay: a = (\n)
+    E123: a = (\n    )
+
+    Okay: a = (\n    42)
+    E121: a = (\n   42)
+    E122: a = (\n42)
+    E123: a = (\n    42\n    )
+    E124: a = (24,\n     42\n)
+    E125: if (\n    b):\n    pass
+    E126: a = (\n        42)
+    E127: a = (24,\n      42)
+    E128: a = (24,\n    42)
+    E129: if (a or\n    b):\n    pass
+    E131: a = (\n    42\n 24)
+    """
+    first_row = tokens[0][2][0]
+    nrows = 1 + tokens[-1][2][0] - first_row
+    if noqa or nrows == 1:
+        return
+
+    # indent_next tells us whether the next block is indented; assuming
+    # that it is indented by 4 spaces, then we should not allow 4-space
+    # indents on the final continuation line; in turn, some other
+    # indents are allowed to have an extra 4 spaces.
+    indent_next = logical_line.endswith(':')
+
+    row = depth = 0
+    valid_hangs = (4,) if indent_char != '\t' else (4, 8)
+    # remember how many brackets were opened on each line
+    parens = [0] * nrows
+    # relative indents of physical lines
+    rel_indent = [0] * nrows
+    # for each depth, collect a list of opening rows
+    open_rows = [[0]]
+    # for each depth, memorize the hanging indentation
+    hangs = [None]
+    # visual indents
+    indent_chances = {}
+    last_indent = tokens[0][2]
+    visual_indent = None
+    last_token_multiline = False
+    # for each depth, memorize the visual indent column
+    indent = [last_indent[1]]
+    if verbose >= 3:
+        print(">>> " + tokens[0][4].rstrip())
+
+    for token_type, text, start, end, line in tokens:
+
+        newline = row < start[0] - first_row
+        if newline:
+            row = start[0] - first_row
+            newline = not last_token_multiline and token_type not in NEWLINE
+
+        if newline:
+            # this is the beginning of a continuation line.
+            last_indent = start
+            if verbose >= 3:
+                print("... " + line.rstrip())
+
+            # record the initial indent.
+            rel_indent[row] = expand_indent(line) - indent_level
+
+            # identify closing bracket
+            close_bracket = (token_type == tokenize.OP and text in ']})')
+
+            # is the indent relative to an opening bracket line?
+            for open_row in reversed(open_rows[depth]):
+                hang = rel_indent[row] - rel_indent[open_row]
+                hanging_indent = hang in valid_hangs
+                if hanging_indent:
+                    break
+            if hangs[depth]:
+                hanging_indent = (hang == hangs[depth])
+            # is there any chance of visual indent?
+            visual_indent = (not close_bracket and hang > 0 and
+                             indent_chances.get(start[1]))
+
+            if close_bracket and indent[depth]:
+                # closing bracket for visual indent
+                if start[1] != indent[depth]:
+                    yield (start, "E124 closing bracket does not match "
+                           "visual indentation")
+            elif close_bracket and not hang:
+                # closing bracket matches indentation of opening bracket's line
+                if hang_closing:
+                    yield start, "E133 closing bracket is missing indentation"
+            elif indent[depth] and start[1] < indent[depth]:
+                if visual_indent is not True:
+                    # visual indent is broken
+                    yield (start, "E128 continuation line "
+                           "under-indented for visual indent")
+            elif hanging_indent or (indent_next and rel_indent[row] == 8):
+                # hanging indent is verified
+                if close_bracket and not hang_closing:
+                    yield (start, "E123 closing bracket does not match "
+                           "indentation of opening bracket's line")
+                hangs[depth] = hang
+            elif visual_indent is True:
+                # visual indent is verified
+                indent[depth] = start[1]
+            elif visual_indent in (text, str):
+                # ignore token lined up with matching one from a previous line
+                pass
+            else:
+                # indent is broken
+                if hang <= 0:
+                    error = "E122", "missing indentation or outdented"
+                elif indent[depth]:
+                    error = "E127", "over-indented for visual indent"
+                elif not close_bracket and hangs[depth]:
+                    error = "E131", "unaligned for hanging indent"
+                else:
+                    hangs[depth] = hang
+                    if hang > 4:
+                        error = "E126", "over-indented for hanging indent"
+                    else:
+                        error = "E121", "under-indented for hanging indent"
+                yield start, "%s continuation line %s" % error
+
+        # look for visual indenting
+        if (parens[row] and
+                token_type not in (tokenize.NL, tokenize.COMMENT) and
+                not indent[depth]):
+            indent[depth] = start[1]
+            indent_chances[start[1]] = True
+            if verbose >= 4:
+                print("bracket depth %s indent to %s" % (depth, start[1]))
+        # deal with implicit string concatenation
+        elif (token_type in (tokenize.STRING, tokenize.COMMENT) or
+              text in ('u', 'ur', 'b', 'br')):
+            indent_chances[start[1]] = str
+        # special case for the "if" statement because len("if (") == 4
+        elif not indent_chances and not row and not depth and text == 'if':
+            indent_chances[end[1] + 1] = True
+        elif text == ':' and line[end[1]:].isspace():
+            open_rows[depth].append(row)
+
+        # keep track of bracket depth
+        if token_type == tokenize.OP:
+            if text in '([{':
+                depth += 1
+                indent.append(0)
+                hangs.append(None)
+                if len(open_rows) == depth:
+                    open_rows.append([])
+                open_rows[depth].append(row)
+                parens[row] += 1
+                if verbose >= 4:
+                    print("bracket depth %s seen, col %s, visual min = %s" %
+                          (depth, start[1], indent[depth]))
+            elif text in ')]}' and depth > 0:
+                # parent indents should not be more than this one
+                prev_indent = indent.pop() or last_indent[1]
+                hangs.pop()
+                for d in range(depth):
+                    if indent[d] > prev_indent:
+                        indent[d] = 0
+                for ind in list(indent_chances):
+                    if ind >= prev_indent:
+                        del indent_chances[ind]
+                del open_rows[depth + 1:]
+                depth -= 1
+                if depth:
+                    indent_chances[indent[depth]] = True
+                for idx in range(row, -1, -1):
+                    if parens[idx]:
+                        parens[idx] -= 1
+                        break
+            assert len(indent) == depth + 1
+            if start[1] not in indent_chances:
+                # allow lining up tokens
+                indent_chances[start[1]] = text
+
+        last_token_multiline = (start[0] != end[0])
+        if last_token_multiline:
+            rel_indent[end[0] - first_row] = rel_indent[row]
+
+    if indent_next and expand_indent(line) == indent_level + 4:
+        pos = (start[0], indent[0] + 4)
+        if visual_indent:
+            code = "E129 visually indented line"
+        else:
+            code = "E125 continuation line"
+        yield pos, "%s with same indent as next logical line" % code
+
+
+def whitespace_before_parameters(logical_line, tokens):
+    r"""Avoid extraneous whitespace.
+
+    Avoid extraneous whitespace in the following situations:
+    - before the open parenthesis that starts the argument list of a
+      function call.
+    - before the open parenthesis that starts an indexing or slicing.
+
+    Okay: spam(1)
+    E211: spam (1)
+
+    Okay: dict['key'] = list[index]
+    E211: dict ['key'] = list[index]
+    E211: dict['key'] = list [index]
+    """
+    prev_type, prev_text, __, prev_end, __ = tokens[0]
+    for index in range(1, len(tokens)):
+        token_type, text, start, end, __ = tokens[index]
+        if (token_type == tokenize.OP and
+            text in '([' and
+            start != prev_end and
+            (prev_type == tokenize.NAME or prev_text in '}])') and
+            # Syntax "class A (B):" is allowed, but avoid it
+            (index < 2 or tokens[index - 2][1] != 'class') and
+                # Allow "return (a.foo for a in range(5))"
+                not keyword.iskeyword(prev_text)):
+            yield prev_end, "E211 whitespace before '%s'" % text
+        prev_type = token_type
+        prev_text = text
+        prev_end = end
+
+
+def whitespace_around_operator(logical_line):
+    r"""Avoid extraneous whitespace around an operator.
+
+    Okay: a = 12 + 3
+    E221: a = 4  + 5
+    E222: a = 4 +  5
+    E223: a = 4\t+ 5
+    E224: a = 4 +\t5
+    """
+    for match in OPERATOR_REGEX.finditer(logical_line):
+        before, after = match.groups()
+
+        if '\t' in before:
+            yield match.start(1), "E223 tab before operator"
+        elif len(before) > 1:
+            yield match.start(1), "E221 multiple spaces before operator"
+
+        if '\t' in after:
+            yield match.start(2), "E224 tab after operator"
+        elif len(after) > 1:
+            yield match.start(2), "E222 multiple spaces after operator"
+
+
+def missing_whitespace_around_operator(logical_line, tokens):
+    r"""Surround operators with a single space on either side.
+
+    - Always surround these binary operators with a single space on
+      either side: assignment (=), augmented assignment (+=, -= etc.),
+      comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
+      Booleans (and, or, not).
+
+    - If operators with different priorities are used, consider adding
+      whitespace around the operators with the lowest priorities.
+
+    Okay: i = i + 1
+    Okay: submitted += 1
+    Okay: x = x * 2 - 1
+    Okay: hypot2 = x * x + y * y
+    Okay: c = (a + b) * (a - b)
+    Okay: foo(bar, key='word', *args, **kwargs)
+    Okay: alpha[:-i]
+
+    E225: i=i+1
+    E225: submitted +=1
+    E225: x = x /2 - 1
+    E225: z = x **y
+    E226: c = (a+b) * (a-b)
+    E226: hypot2 = x*x + y*y
+    E227: c = a|b
+    E228: msg = fmt%(errno, errmsg)
+    """
+    parens = 0
+    need_space = False
+    prev_type = tokenize.OP
+    prev_text = prev_end = None
+    for token_type, text, start, end, line in tokens:
+        if token_type in SKIP_COMMENTS:
+            continue
+        if text in ('(', 'lambda'):
+            parens += 1
+        elif text == ')':
+            parens -= 1
+        if need_space:
+            if start != prev_end:
+                # Found a (probably) needed space
+                if need_space is not True and not need_space[1]:
+                    yield (need_space[0],
+                           "E225 missing whitespace around operator")
+                need_space = False
+            elif text == '>' and prev_text in ('<', '-'):
+                # Tolerate the "<>" operator, even if running Python 3
+                # Deal with Python 3's annotated return value "->"
+                pass
+            else:
+                if need_space is True or need_space[1]:
+                    # A needed trailing space was not found
+                    yield prev_end, "E225 missing whitespace around operator"
+                elif prev_text != '**':
+                    code, optype = 'E226', 'arithmetic'
+                    if prev_text == '%':
+                        code, optype = 'E228', 'modulo'
+                    elif prev_text not in ARITHMETIC_OP:
+                        code, optype = 'E227', 'bitwise or shift'
+                    yield (need_space[0], "%s missing whitespace "
+                           "around %s operator" % (code, optype))
+                need_space = False
+        elif token_type == tokenize.OP and prev_end is not None:
+            if text == '=' and parens:
+                # Allow keyword args or defaults: foo(bar=None).
+                pass
+            elif text in WS_NEEDED_OPERATORS:
+                need_space = True
+            elif text in UNARY_OPERATORS:
+                # Check if the operator is being used as a binary operator
+                # Allow unary operators: -123, -x, +1.
+                # Allow argument unpacking: foo(*args, **kwargs).
+                if (prev_text in '}])' if prev_type == tokenize.OP
+                        else prev_text not in KEYWORDS):
+                    need_space = None
+            elif text in WS_OPTIONAL_OPERATORS:
+                need_space = None
+
+            if need_space is None:
+                # Surrounding space is optional, but ensure that
+                # trailing space matches opening space
+                need_space = (prev_end, start != prev_end)
+            elif need_space and start == prev_end:
+                # A needed opening space was not found
+                yield prev_end, "E225 missing whitespace around operator"
+                need_space = False
+        prev_type = token_type
+        prev_text = text
+        prev_end = end
+
+
+def whitespace_around_comma(logical_line):
+    r"""Avoid extraneous whitespace after a comma or a colon.
+
+    Note: these checks are disabled by default
+
+    Okay: a = (1, 2)
+    E241: a = (1,  2)
+    E242: a = (1,\t2)
+    """
+    line = logical_line
+    for m in WHITESPACE_AFTER_COMMA_REGEX.finditer(line):
+        found = m.start() + 1
+        if '\t' in m.group():
+            yield found, "E242 tab after '%s'" % m.group()[0]
+        else:
+            yield found, "E241 multiple spaces after '%s'" % m.group()[0]
+
+
+def whitespace_around_named_parameter_equals(logical_line, tokens):
+    r"""Don't use spaces around the '=' sign in function arguments.
+
+    Don't use spaces around the '=' sign when used to indicate a
+    keyword argument or a default parameter value.
+
+    Okay: def complex(real, imag=0.0):
+    Okay: return magic(r=real, i=imag)
+    Okay: boolean(a == b)
+    Okay: boolean(a != b)
+    Okay: boolean(a <= b)
+    Okay: boolean(a >= b)
+    Okay: def foo(arg: int = 42):
+    Okay: async def foo(arg: int = 42):
+
+    E251: def complex(real, imag = 0.0):
+    E251: return magic(r = real, i = imag)
+    """
+    parens = 0
+    no_space = False
+    prev_end = None
+    annotated_func_arg = False
+    in_def = logical_line.startswith(('def', 'async def'))
+    message = "E251 unexpected spaces around keyword / parameter equals"
+    for token_type, text, start, end, line in tokens:
+        if token_type == tokenize.NL:
+            continue
+        if no_space:
+            no_space = False
+            if start != prev_end:
+                yield (prev_end, message)
+        if token_type == tokenize.OP:
+            if text in '([':
+                parens += 1
+            elif text in ')]':
+                parens -= 1
+            elif in_def and text == ':' and parens == 1:
+                annotated_func_arg = True
+            elif parens and text == ',' and parens == 1:
+                annotated_func_arg = False
+            elif parens and text == '=' and not annotated_func_arg:
+                no_space = True
+                if start != prev_end:
+                    yield (prev_end, message)
+            if not parens:
+                annotated_func_arg = False
+
+        prev_end = end
+
+
+def whitespace_before_comment(logical_line, tokens):
+    r"""Separate inline comments by at least two spaces.
+
+    An inline comment is a comment on the same line as a statement.  Inline
+    comments should be separated by at least two spaces from the statement.
+    They should start with a # and a single space.
+
+    Each line of a block comment starts with a # and a single space
+    (unless it is indented text inside the comment).
+
+    Okay: x = x + 1  # Increment x
+    Okay: x = x + 1    # Increment x
+    Okay: # Block comment
+    E261: x = x + 1 # Increment x
+    E262: x = x + 1  #Increment x
+    E262: x = x + 1  #  Increment x
+    E265: #Block comment
+    E266: ### Block comment
+    """
+    prev_end = (0, 0)
+    for token_type, text, start, end, line in tokens:
+        if token_type == tokenize.COMMENT:
+            inline_comment = line[:start[1]].strip()
+            if inline_comment:
+                if prev_end[0] == start[0] and start[1] < prev_end[1] + 2:
+                    yield (prev_end,
+                           "E261 at least two spaces before inline comment")
+            symbol, sp, comment = text.partition(' ')
+            bad_prefix = symbol not in '#:' and (symbol.lstrip('#')[:1] or '#')
+            if inline_comment:
+                if bad_prefix or comment[:1] in WHITESPACE:
+                    yield start, "E262 inline comment should start with '# '"
+            elif bad_prefix and (bad_prefix != '!' or start[0] > 1):
+                if bad_prefix != '#':
+                    yield start, "E265 block comment should start with '# '"
+                elif comment:
+                    yield start, "E266 too many leading '#' for block comment"
+        elif token_type != tokenize.NL:
+            prev_end = end
+
+
+def imports_on_separate_lines(logical_line):
+    r"""Place imports on separate lines.
+
+    Okay: import os\nimport sys
+    E401: import sys, os
+
+    Okay: from subprocess import Popen, PIPE
+    Okay: from myclas import MyClass
+    Okay: from foo.bar.yourclass import YourClass
+    Okay: import myclass
+    Okay: import foo.bar.yourclass
+    """
+    line = logical_line
+    if line.startswith('import '):
+        found = line.find(',')
+        if -1 < found and ';' not in line[:found]:
+            yield found, "E401 multiple imports on one line"
+
+
+def module_imports_on_top_of_file(
+        logical_line, indent_level, checker_state, noqa):
+    r"""Place imports at the top of the file.
+
+    Always put imports at the top of the file, just after any module comments
+    and docstrings, and before module globals and constants.
+
+    Okay: import os
+    Okay: # this is a comment\nimport os
+    Okay: '''this is a module docstring'''\nimport os
+    Okay: r'''this is a module docstring'''\nimport os
+    Okay: try:\n    import x\nexcept:\n    pass\nelse:\n    pass\nimport y
+    Okay: try:\n    import x\nexcept:\n    pass\nfinally:\n    pass\nimport y
+    E402: a=1\nimport os
+    E402: 'One string'\n"Two string"\nimport os
+    E402: a=1\nfrom sys import x
+
+    Okay: if x:\n    import os
+    """
+    def is_string_literal(line):
+        if line[0] in 'uUbB':
+            line = line[1:]
+        if line and line[0] in 'rR':
+            line = line[1:]
+        return line and (line[0] == '"' or line[0] == "'")
+
+    allowed_try_keywords = ('try', 'except', 'else', 'finally')
+
+    if indent_level:  # Allow imports in conditional statements or functions
+        return
+    if not logical_line:  # Allow empty lines or comments
+        return
+    if noqa:
+        return
+    line = logical_line
+    if line.startswith('import ') or line.startswith('from '):
+        if checker_state.get('seen_non_imports', False):
+            yield 0, "E402 module level import not at top of file"
+    elif any(line.startswith(kw) for kw in allowed_try_keywords):
+        # Allow try, except, else, finally keywords intermixed with imports in
+        # order to support conditional importing
+        return
+    elif is_string_literal(line):
+        # The first literal is a docstring, allow it. Otherwise, report error.
+        if checker_state.get('seen_docstring', False):
+            checker_state['seen_non_imports'] = True
+        else:
+            checker_state['seen_docstring'] = True
+    else:
+        checker_state['seen_non_imports'] = True
+
+
+def compound_statements(logical_line):
+    r"""Compound statements (on the same line) are generally discouraged.
+
+    While sometimes it's okay to put an if/for/while with a small body
+    on the same line, never do this for multi-clause statements.
+    Also avoid folding such long lines!
+
+    Always use a def statement instead of an assignment statement that
+    binds a lambda expression directly to a name.
+
+    Okay: if foo == 'blah':\n    do_blah_thing()
+    Okay: do_one()
+    Okay: do_two()
+    Okay: do_three()
+
+    E701: if foo == 'blah': do_blah_thing()
+    E701: for x in lst: total += x
+    E701: while t < 10: t = delay()
+    E701: if foo == 'blah': do_blah_thing()
+    E701: else: do_non_blah_thing()
+    E701: try: something()
+    E701: finally: cleanup()
+    E701: if foo == 'blah': one(); two(); three()
+    E702: do_one(); do_two(); do_three()
+    E703: do_four();  # useless semicolon
+    E704: def f(x): return 2*x
+    E731: f = lambda x: 2*x
+    """
+    line = logical_line
+    last_char = len(line) - 1
+    found = line.find(':')
+    prev_found = 0
+    counts = dict((char, 0) for char in '{}[]()')
+    while -1 < found < last_char:
+        update_counts(line[prev_found:found], counts)
+        if ((counts['{'] <= counts['}'] and   # {'a': 1} (dict)
+             counts['['] <= counts[']'] and   # [1:2] (slice)
+             counts['('] <= counts[')'])):    # (annotation)
+            lambda_kw = LAMBDA_REGEX.search(line, 0, found)
+            if lambda_kw:
+                before = line[:lambda_kw.start()].rstrip()
+                if before[-1:] == '=' and isidentifier(before[:-1].strip()):
+                    yield 0, ("E731 do not assign a lambda expression, use a "
+                              "def")
+                break
+            if line.startswith('def '):
+                yield 0, "E704 multiple statements on one line (def)"
+            else:
+                yield found, "E701 multiple statements on one line (colon)"
+        prev_found = found
+        found = line.find(':', found + 1)
+    found = line.find(';')
+    while -1 < found:
+        if found < last_char:
+            yield found, "E702 multiple statements on one line (semicolon)"
+        else:
+            yield found, "E703 statement ends with a semicolon"
+        found = line.find(';', found + 1)
+
+
+def explicit_line_join(logical_line, tokens):
+    r"""Avoid explicit line join between brackets.
+
+    The preferred way of wrapping long lines is by using Python's implied line
+    continuation inside parentheses, brackets and braces.  Long lines can be
+    broken over multiple lines by wrapping expressions in parentheses.  These
+    should be used in preference to using a backslash for line continuation.
+
+    E502: aaa = [123, \\n       123]
+    E502: aaa = ("bbb " \\n       "ccc")
+
+    Okay: aaa = [123,\n       123]
+    Okay: aaa = ("bbb "\n       "ccc")
+    Okay: aaa = "bbb " \\n    "ccc"
+    Okay: aaa = 123  # \\
+    """
+    prev_start = prev_end = parens = 0
+    comment = False
+    backslash = None
+    for token_type, text, start, end, line in tokens:
+        if token_type == tokenize.COMMENT:
+            comment = True
+        if start[0] != prev_start and parens and backslash and not comment:
+            yield backslash, "E502 the backslash is redundant between brackets"
+        if end[0] != prev_end:
+            if line.rstrip('\r\n').endswith('\\'):
+                backslash = (end[0], len(line.splitlines()[-1]) - 1)
+            else:
+                backslash = None
+            prev_start = prev_end = end[0]
+        else:
+            prev_start = start[0]
+        if token_type == tokenize.OP:
+            if text in '([{':
+                parens += 1
+            elif text in ')]}':
+                parens -= 1
+
+
+def break_around_binary_operator(logical_line, tokens):
+    r"""
+    Avoid breaks before binary operators.
+
+    The preferred place to break around a binary operator is after the
+    operator, not before it.
+
+    W503: (width == 0\n + height == 0)
+    W503: (width == 0\n and height == 0)
+
+    Okay: (width == 0 +\n height == 0)
+    Okay: foo(\n    -x)
+    Okay: foo(x\n    [])
+    Okay: x = '''\n''' + ''
+    Okay: foo(x,\n    -y)
+    Okay: foo(x,  # comment\n    -y)
+    Okay: var = (1 &\n       ~2)
+    Okay: var = (1 /\n       -2)
+    Okay: var = (1 +\n       -1 +\n       -2)
+    """
+    def is_binary_operator(token_type, text):
+        # The % character is strictly speaking a binary operator, but the
+        # common usage seems to be to put it next to the format parameters,
+        # after a line break.
+        return ((token_type == tokenize.OP or text in ['and', 'or']) and
+                text not in "()[]{},:.;@=%~")
+
+    line_break = False
+    unary_context = True
+    # Previous non-newline token types and text
+    previous_token_type = None
+    previous_text = None
+    for token_type, text, start, end, line in tokens:
+        if token_type == tokenize.COMMENT:
+            continue
+        if ('\n' in text or '\r' in text) and token_type != tokenize.STRING:
+            line_break = True
+        else:
+            if (is_binary_operator(token_type, text) and line_break and
+                    not unary_context and
+                    not is_binary_operator(previous_token_type,
+                                           previous_text)):
+                yield start, "W503 line break before binary operator"
+            unary_context = text in '([{,;'
+            line_break = False
+            previous_token_type = token_type
+            previous_text = text
+
+
+def comparison_to_singleton(logical_line, noqa):
+    r"""Comparison to singletons should use "is" or "is not".
+
+    Comparisons to singletons like None should always be done
+    with "is" or "is not", never the equality operators.
+
+    Okay: if arg is not None:
+    E711: if arg != None:
+    E711: if None == arg:
+    E712: if arg == True:
+    E712: if False == arg:
+
+    Also, beware of writing if x when you really mean if x is not None --
+    e.g. when testing whether a variable or argument that defaults to None was
+    set to some other value.  The other value might have a type (such as a
+    container) that could be false in a boolean context!
+    """
+    match = not noqa and COMPARE_SINGLETON_REGEX.search(logical_line)
+    if match:
+        singleton = match.group(1) or match.group(3)
+        same = (match.group(2) == '==')
+
+        msg = "'if cond is %s:'" % (('' if same else 'not ') + singleton)
+        if singleton in ('None',):
+            code = 'E711'
+        else:
+            code = 'E712'
+            nonzero = ((singleton == 'True' and same) or
+                       (singleton == 'False' and not same))
+            msg += " or 'if %scond:'" % ('' if nonzero else 'not ')
+        yield match.start(2), ("%s comparison to %s should be %s" %
+                               (code, singleton, msg))
+
+
+def comparison_negative(logical_line):
+    r"""Negative comparison should be done using "not in" and "is not".
+
+    Okay: if x not in y:\n    pass
+    Okay: assert (X in Y or X is Z)
+    Okay: if not (X in Y):\n    pass
+    Okay: zz = x is not y
+    E713: Z = not X in Y
+    E713: if not X.B in Y:\n    pass
+    E714: if not X is Y:\n    pass
+    E714: Z = not X.B is Y
+    """
+    match = COMPARE_NEGATIVE_REGEX.search(logical_line)
+    if match:
+        pos = match.start(1)
+        if match.group(2) == 'in':
+            yield pos, "E713 test for membership should be 'not in'"
+        else:
+            yield pos, "E714 test for object identity should be 'is not'"
+
+
+def comparison_type(logical_line, noqa):
+    r"""Object type comparisons should always use isinstance().
+
+    Do not compare types directly.
+
+    Okay: if isinstance(obj, int):
+    E721: if type(obj) is type(1):
+
+    When checking if an object is a string, keep in mind that it might be a
+    unicode string too! In Python 2.3, str and unicode have a common base
+    class, basestring, so you can do:
+
+    Okay: if isinstance(obj, basestring):
+    Okay: if type(a1) is type(b1):
+    """
+    match = COMPARE_TYPE_REGEX.search(logical_line)
+    if match and not noqa:
+        inst = match.group(1)
+        if inst and isidentifier(inst) and inst not in SINGLETONS:
+            return  # Allow comparison for types which are not obvious
+        yield match.start(), "E721 do not compare types, use 'isinstance()'"
+
+
+def ambiguous_identifier(logical_line, tokens):
+    r"""Never use the characters 'l', 'O', or 'I' as variable names.
+
+    In some fonts, these characters are indistinguishable from the numerals
+    one and zero. When tempted to use 'l', use 'L' instead.
+
+    Okay: L = 0
+    Okay: o = 123
+    Okay: i = 42
+    E741: l = 0
+    E741: O = 123
+    E741: I = 42
+
+    Variables can be bound in several other contexts, including class and
+    function definitions, 'global' and 'nonlocal' statements, exception
+    handlers, and 'with' statements.
+
+    Okay: except AttributeError as o:
+    Okay: with lock as L:
+    E741: except AttributeError as O:
+    E741: with lock as l:
+    E741: global I
+    E741: nonlocal l
+    E742: class I(object):
+    E743: def l(x):
+    """
+    idents_to_avoid = ('l', 'O', 'I')
+    prev_type, prev_text, prev_start, prev_end, __ = tokens[0]
+    for token_type, text, start, end, line in tokens[1:]:
+        ident = pos = None
+        # identifiers on the lhs of an assignment operator
+        if token_type == tokenize.OP and '=' in text:
+            if prev_text in idents_to_avoid:
+                ident = prev_text
+                pos = prev_start
+        # identifiers bound to a value with 'as', 'global', or 'nonlocal'
+        if prev_text in ('as', 'global', 'nonlocal'):
+            if text in idents_to_avoid:
+                ident = text
+                pos = start
+        if prev_text == 'class':
+            if text in idents_to_avoid:
+                yield start, "E742 ambiguous class definition '%s'" % text
+        if prev_text == 'def':
+            if text in idents_to_avoid:
+                yield start, "E743 ambiguous function definition '%s'" % text
+        if ident:
+            yield pos, "E741 ambiguous variable name '%s'" % ident
+        prev_text = text
+        prev_start = start
+
+
+def python_3000_has_key(logical_line, noqa):
+    r"""The {}.has_key() method is removed in Python 3: use the 'in' operator.
+
+    Okay: if "alph" in d:\n    print(d["alph"])
+    W601: assert d.has_key('alph')
+    """
+    pos = logical_line.find('.has_key(')
+    if pos > -1 and not noqa:
+        yield pos, "W601 .has_key() is deprecated, use 'in'"
+
+
+def python_3000_raise_comma(logical_line):
+    r"""When raising an exception, use "raise ValueError('message')".
+
+    The older form is removed in Python 3.
+
+    Okay: raise DummyError("Message")
+    W602: raise DummyError, "Message"
+    """
+    match = RAISE_COMMA_REGEX.match(logical_line)
+    if match and not RERAISE_COMMA_REGEX.match(logical_line):
+        yield match.end() - 1, "W602 deprecated form of raising exception"
+
+
+def python_3000_not_equal(logical_line):
+    r"""New code should always use != instead of <>.
+
+    The older syntax is removed in Python 3.
+
+    Okay: if a != 'no':
+    W603: if a <> 'no':
+    """
+    pos = logical_line.find('<>')
+    if pos > -1:
+        yield pos, "W603 '<>' is deprecated, use '!='"
+
+
+def python_3000_backticks(logical_line):
+    r"""Use repr() instead of backticks in Python 3.
+
+    Okay: val = repr(1 + 2)
+    W604: val = `1 + 2`
+    """
+    pos = logical_line.find('`')
+    if pos > -1:
+        yield pos, "W604 backticks are deprecated, use 'repr()'"
+
+
+##############################################################################
+# Helper functions
+##############################################################################
+
+
+if sys.version_info < (3,):
+    # Python 2: implicit encoding.
+    def readlines(filename):
+        """Read the source code."""
+        with open(filename, 'rU') as f:
+            return f.readlines()
+    isidentifier = re.compile(r'[a-zA-Z_]\w*$').match
+    stdin_get_value = sys.stdin.read
+else:
+    # Python 3
+    def readlines(filename):
+        """Read the source code."""
+        try:
+            with open(filename, 'rb') as f:
+                (coding, lines) = tokenize.detect_encoding(f.readline)
+                f = TextIOWrapper(f, coding, line_buffering=True)
+                return [line.decode(coding) for line in lines] + f.readlines()
+        except (LookupError, SyntaxError, UnicodeError):
+            # Fall back if file encoding is improperly declared
+            with open(filename, encoding='latin-1') as f:
+                return f.readlines()
+    isidentifier = str.isidentifier
+
+    def stdin_get_value():
+        """Read the value from stdin."""
+        return TextIOWrapper(sys.stdin.buffer, errors='ignore').read()
+
+noqa = re.compile(r'# no(?:qa|pep8)\b', re.I).search
+
+
+def expand_indent(line):
+    r"""Return the amount of indentation.
+
+    Tabs are expanded to the next multiple of 8.
+
+    >>> expand_indent('    ')
+    4
+    >>> expand_indent('\t')
+    8
+    >>> expand_indent('       \t')
+    8
+    >>> expand_indent('        \t')
+    16
+    """
+    if '\t' not in line:
+        return len(line) - len(line.lstrip())
+    result = 0
+    for char in line:
+        if char == '\t':
+            result = result // 8 * 8 + 8
+        elif char == ' ':
+            result += 1
+        else:
+            break
+    return result
+
+
+def mute_string(text):
+    """Replace contents with 'xxx' to prevent syntax matching.
+
+    >>> mute_string('"abc"')
+    '"xxx"'
+    >>> mute_string("'''abc'''")
+    "'''xxx'''"
+    >>> mute_string("r'abc'")
+    "r'xxx'"
+    """
+    # String modifiers (e.g. u or r)
+    start = text.index(text[-1]) + 1
+    end = len(text) - 1
+    # Triple quotes
+    if text[-3:] in ('"""', "'''"):
+        start += 2
+        end -= 2
+    return text[:start] + 'x' * (end - start) + text[end:]
+
+
+def parse_udiff(diff, patterns=None, parent='.'):
+    """Return a dictionary of matching lines."""
+    # For each file of the diff, the entry key is the filename,
+    # and the value is a set of row numbers to consider.
+    rv = {}
+    path = nrows = None
+    for line in diff.splitlines():
+        if nrows:
+            if line[:1] != '-':
+                nrows -= 1
+            continue
+        if line[:3] == '@@ ':
+            hunk_match = HUNK_REGEX.match(line)
+            (row, nrows) = [int(g or '1') for g in hunk_match.groups()]
+            rv[path].update(range(row, row + nrows))
+        elif line[:3] == '+++':
+            path = line[4:].split('\t', 1)[0]
+            if path[:2] == 'b/':
+                path = path[2:]
+            rv[path] = set()
+    return dict([(os.path.join(parent, path), rows)
+                 for (path, rows) in rv.items()
+                 if rows and filename_match(path, patterns)])
+
+
+def normalize_paths(value, parent=os.curdir):
+    """Parse a comma-separated list of paths.
+
+    Return a list of absolute paths.
+    """
+    if not value:
+        return []
+    if isinstance(value, list):
+        return value
+    paths = []
+    for path in value.split(','):
+        path = path.strip()
+        if '/' in path:
+            path = os.path.abspath(os.path.join(parent, path))
+        paths.append(path.rstrip('/'))
+    return paths
+
+
+def filename_match(filename, patterns, default=True):
+    """Check if patterns contains a pattern that matches filename.
+
+    If patterns is unspecified, this always returns True.
+    """
+    if not patterns:
+        return default
+    return any(fnmatch(filename, pattern) for pattern in patterns)
+
+
+def update_counts(s, counts):
+    r"""Adds one to the counts of each appearance of characters in s,
+        for characters in counts"""
+    for char in s:
+        if char in counts:
+            counts[char] += 1
+
+
+def _is_eol_token(token):
+    return token[0] in NEWLINE or token[4][token[3][1]:].lstrip() == '\\\n'
+
+
+if COMMENT_WITH_NL:
+    def _is_eol_token(token, _eol_token=_is_eol_token):
+        return _eol_token(token) or (token[0] == tokenize.COMMENT and
+                                     token[1] == token[4])
+
+##############################################################################
+# Framework to run all checks
+##############################################################################
+
+
+_checks = {'physical_line': {}, 'logical_line': {}, 'tree': {}}
+
+
+def _get_parameters(function):
+    if sys.version_info >= (3, 3):
+        return [parameter.name
+                for parameter
+                in inspect.signature(function).parameters.values()
+                if parameter.kind == parameter.POSITIONAL_OR_KEYWORD]
+    else:
+        return inspect.getargspec(function)[0]
+
+
+def register_check(check, codes=None):
+    """Register a new check object."""
+    def _add_check(check, kind, codes, args):
+        if check in _checks[kind]:
+            _checks[kind][check][0].extend(codes or [])
+        else:
+            _checks[kind][check] = (codes or [''], args)
+    if inspect.isfunction(check):
+        args = _get_parameters(check)
+        if args and args[0] in ('physical_line', 'logical_line'):
+            if codes is None:
+                codes = ERRORCODE_REGEX.findall(check.__doc__ or '')
+            _add_check(check, args[0], codes, args)
+    elif inspect.isclass(check):
+        if _get_parameters(check.__init__)[:2] == ['self', 'tree']:
+            _add_check(check, 'tree', codes, None)
+
+
+def init_checks_registry():
+    """Register all globally visible functions.
+
+    The first argument name is either 'physical_line' or 'logical_line'.
+    """
+    mod = inspect.getmodule(register_check)
+    for (name, function) in inspect.getmembers(mod, inspect.isfunction):
+        register_check(function)
+
+
+init_checks_registry()
+
+
+class Checker(object):
+    """Load a Python source file, tokenize it, check coding style."""
+
+    def __init__(self, filename=None, lines=None,
+                 options=None, report=None, **kwargs):
+        if options is None:
+            options = StyleGuide(kwargs).options
+        else:
+            assert not kwargs
+        self._io_error = None
+        self._physical_checks = options.physical_checks
+        self._logical_checks = options.logical_checks
+        self._ast_checks = options.ast_checks
+        self.max_line_length = options.max_line_length
+        self.multiline = False  # in a multiline string?
+        self.hang_closing = options.hang_closing
+        self.verbose = options.verbose
+        self.filename = filename
+        # Dictionary where a checker can store its custom state.
+        self._checker_states = {}
+        if filename is None:
+            self.filename = 'stdin'
+            self.lines = lines or []
+        elif filename == '-':
+            self.filename = 'stdin'
+            self.lines = stdin_get_value().splitlines(True)
+        elif lines is None:
+            try:
+                self.lines = readlines(filename)
+            except IOError:
+                (exc_type, exc) = sys.exc_info()[:2]
+                self._io_error = '%s: %s' % (exc_type.__name__, exc)
+                self.lines = []
+        else:
+            self.lines = lines
+        if self.lines:
+            ord0 = ord(self.lines[0][0])
+            if ord0 in (0xef, 0xfeff):  # Strip the UTF-8 BOM
+                if ord0 == 0xfeff:
+                    self.lines[0] = self.lines[0][1:]
+                elif self.lines[0][:3] == '\xef\xbb\xbf':
+                    self.lines[0] = self.lines[0][3:]
+        self.report = report or options.report
+        self.report_error = self.report.error
+        self.noqa = False
+
+    def report_invalid_syntax(self):
+        """Check if the syntax is valid."""
+        (exc_type, exc) = sys.exc_info()[:2]
+        if len(exc.args) > 1:
+            offset = exc.args[1]
+            if len(offset) > 2:
+                offset = offset[1:3]
+        else:
+            offset = (1, 0)
+        self.report_error(offset[0], offset[1] or 0,
+                          'E901 %s: %s' % (exc_type.__name__, exc.args[0]),
+                          self.report_invalid_syntax)
+
+    def readline(self):
+        """Get the next line from the input buffer."""
+        if self.line_number >= self.total_lines:
+            return ''
+        line = self.lines[self.line_number]
+        self.line_number += 1
+        if self.indent_char is None and line[:1] in WHITESPACE:
+            self.indent_char = line[0]
+        return line
+
+    def run_check(self, check, argument_names):
+        """Run a check plugin."""
+        arguments = []
+        for name in argument_names:
+            arguments.append(getattr(self, name))
+        return check(*arguments)
+
+    def init_checker_state(self, name, argument_names):
+        """Prepare custom state for the specific checker plugin."""
+        if 'checker_state' in argument_names:
+            self.checker_state = self._checker_states.setdefault(name, {})
+
+    def check_physical(self, line):
+        """Run all physical checks on a raw input line."""
+        self.physical_line = line
+        for name, check, argument_names in self._physical_checks:
+            self.init_checker_state(name, argument_names)
+            result = self.run_check(check, argument_names)
+            if result is not None:
+                (offset, text) = result
+                self.report_error(self.line_number, offset, text, check)
+                if text[:4] == 'E101':
+                    self.indent_char = line[0]
+
+    def build_tokens_line(self):
+        """Build a logical line from tokens."""
+        logical = []
+        comments = []
+        length = 0
+        prev_row = prev_col = mapping = None
+        for token_type, text, start, end, line in self.tokens:
+            if token_type in SKIP_TOKENS:
+                continue
+            if not mapping:
+                mapping = [(0, start)]
+            if token_type == tokenize.COMMENT:
+                comments.append(text)
+                continue
+            if token_type == tokenize.STRING:
+                text = mute_string(text)
+            if prev_row:
+                (start_row, start_col) = start
+                if prev_row != start_row:    # different row
+                    prev_text = self.lines[prev_row - 1][prev_col - 1]
+                    if prev_text == ',' or (prev_text not in '{[(' and
+                                            text not in '}])'):
+                        text = ' ' + text
+                elif prev_col != start_col:  # different column
+                    text = line[prev_col:start_col] + text
+            logical.append(text)
+            length += len(text)
+            mapping.append((length, end))
+            (prev_row, prev_col) = end
+        self.logical_line = ''.join(logical)
+        self.noqa = comments and noqa(''.join(comments))
+        return mapping
+
+    def check_logical(self):
+        """Build a line from tokens and run all logical checks on it."""
+        self.report.increment_logical_line()
+        mapping = self.build_tokens_line()
+
+        if not mapping:
+            return
+
+        (start_row, start_col) = mapping[0][1]
+        start_line = self.lines[start_row - 1]
+        self.indent_level = expand_indent(start_line[:start_col])
+        if self.blank_before < self.blank_lines:
+            self.blank_before = self.blank_lines
+        if self.verbose >= 2:
+            print(self.logical_line[:80].rstrip())
+        for name, check, argument_names in self._logical_checks:
+            if self.verbose >= 4:
+                print('   ' + name)
+            self.init_checker_state(name, argument_names)
+            for offset, text in self.run_check(check, argument_names) or ():
+                if not isinstance(offset, tuple):
+                    for token_offset, pos in mapping:
+                        if offset <= token_offset:
+                            break
+                    offset = (pos[0], pos[1] + offset - token_offset)
+                self.report_error(offset[0], offset[1], text, check)
+        if self.logical_line:
+            self.previous_indent_level = self.indent_level
+            self.previous_logical = self.logical_line
+            if not self.indent_level:
+                self.previous_unindented_logical_line = self.logical_line
+        self.blank_lines = 0
+        self.tokens = []
+
+    def check_ast(self):
+        """Build the file's AST and run all AST checks."""
+        try:
+            tree = compile(''.join(self.lines), '', 'exec', PyCF_ONLY_AST)
+        except (ValueError, SyntaxError, TypeError):
+            return self.report_invalid_syntax()
+        for name, cls, __ in self._ast_checks:
+            checker = cls(tree, self.filename)
+            for lineno, offset, text, check in checker.run():
+                if not self.lines or not noqa(self.lines[lineno - 1]):
+                    self.report_error(lineno, offset, text, check)
+
+    def generate_tokens(self):
+        """Tokenize the file, run physical line checks and yield tokens."""
+        if self._io_error:
+            self.report_error(1, 0, 'E902 %s' % self._io_error, readlines)
+        tokengen = tokenize.generate_tokens(self.readline)
+        try:
+            for token in tokengen:
+                if token[2][0] > self.total_lines:
+                    return
+                self.noqa = token[4] and noqa(token[4])
+                self.maybe_check_physical(token)
+                yield token
+        except (SyntaxError, tokenize.TokenError):
+            self.report_invalid_syntax()
+
+    def maybe_check_physical(self, token):
+        """If appropriate (based on token), check current physical line(s)."""
+        # Called after every token, but act only on end of line.
+        if _is_eol_token(token):
+            # Obviously, a newline token ends a single physical line.
+            self.check_physical(token[4])
+        elif token[0] == tokenize.STRING and '\n' in token[1]:
+            # Less obviously, a string that contains newlines is a
+            # multiline string, either triple-quoted or with internal
+            # newlines backslash-escaped. Check every physical line in the
+            # string *except* for the last one: its newline is outside of
+            # the multiline string, so we consider it a regular physical
+            # line, and will check it like any other physical line.
+            #
+            # Subtleties:
+            # - we don't *completely* ignore the last line; if it contains
+            #   the magical "# noqa" comment, we disable all physical
+            #   checks for the entire multiline string
+            # - have to wind self.line_number back because initially it
+            #   points to the last line of the string, and we want
+            #   check_physical() to give accurate feedback
+            if noqa(token[4]):
+                return
+            self.multiline = True
+            self.line_number = token[2][0]
+            for line in token[1].split('\n')[:-1]:
+                self.check_physical(line + '\n')
+                self.line_number += 1
+            self.multiline = False
+
+    def check_all(self, expected=None, line_offset=0):
+        """Run all checks on the input file."""
+        self.report.init_file(self.filename, self.lines, expected, line_offset)
+        self.total_lines = len(self.lines)
+        if self._ast_checks:
+            self.check_ast()
+        self.line_number = 0
+        self.indent_char = None
+        self.indent_level = self.previous_indent_level = 0
+        self.previous_logical = ''
+        self.previous_unindented_logical_line = ''
+        self.tokens = []
+        self.blank_lines = self.blank_before = 0
+        parens = 0
+        for token in self.generate_tokens():
+            self.tokens.append(token)
+            token_type, text = token[0:2]
+            if self.verbose >= 3:
+                if token[2][0] == token[3][0]:
+                    pos = '[%s:%s]' % (token[2][1] or '', token[3][1])
+                else:
+                    pos = 'l.%s' % token[3][0]
+                print('l.%s\t%s\t%s\t%r' %
+                      (token[2][0], pos, tokenize.tok_name[token[0]], text))
+            if token_type == tokenize.COMMENT or token_type == tokenize.STRING:
+                for sre in re.finditer(r"[:.;,]   ?[A-Za-z]", text):
+                    pos = sre.span()[0]
+                    part = text[:pos]
+                    line = token[2][0] + part.count('\n')
+                    offset = 0 if part.count('\n') > 0 else token[2][1]
+                    col = offset + pos - part.rfind('\n') + 1
+                    if sre.group(0)[0] == '.':
+                        self.report_error(line, col,
+                           'E289 Too many spaces after period. Use only one.',
+                           check=None)
+                    elif sre.group(0)[0] == ',':
+                        self.report_error(line, col,
+                           'E288 Too many spaces after comma. Use only one.',
+                           check=None)
+                    else:
+                        self.report_error(line, col,
+                           'E287 Too many spaces after punctuation. '
+                           'Use only one.',
+                           check=None)
+            if token_type == tokenize.OP:
+                if text in '([{':
+                    parens += 1
+                elif text in '}])':
+                    parens -= 1
+            elif not parens:
+                if token_type in NEWLINE:
+                    if token_type == tokenize.NEWLINE:
+                        self.check_logical()
+                        self.blank_before = 0
+                    elif len(self.tokens) == 1:
+                        # The physical line contains only this token.
+                        self.blank_lines += 1
+                        del self.tokens[0]
+                    else:
+                        self.check_logical()
+                elif COMMENT_WITH_NL and token_type == tokenize.COMMENT:
+                    if len(self.tokens) == 1:
+                        # The comment also ends a physical line
+                        token = list(token)
+                        token[1] = text.rstrip('\r\n')
+                        token[3] = (token[2][0], token[2][1] + len(token[1]))
+                        self.tokens = [tuple(token)]
+                        self.check_logical()
+        if self.tokens:
+            self.check_physical(self.lines[-1])
+            self.check_logical()
+        if self.blank_lines > 1:
+            self.report_error(token[2][0], 0,
+                'E389 File ends in multiple blank lines',
+                check=None)
+        return self.report.get_file_results()
+
+
+class BaseReport(object):
+    """Collect the results of the checks."""
+
+    print_filename = False
+
+    def __init__(self, options):
+        self._benchmark_keys = options.benchmark_keys
+        self._ignore_code = options.ignore_code
+        # Results
+        self.elapsed = 0
+        self.total_errors = 0
+        self.counters = dict.fromkeys(self._benchmark_keys, 0)
+        self.messages = {}
+
+    def start(self):
+        """Start the timer."""
+        self._start_time = time.time()
+
+    def stop(self):
+        """Stop the timer."""
+        self.elapsed = time.time() - self._start_time
+
+    def init_file(self, filename, lines, expected, line_offset):
+        """Signal a new file."""
+        self.filename = filename
+        self.lines = lines
+        self.expected = expected or ()
+        self.line_offset = line_offset
+        self.file_errors = 0
+        self.counters['files'] += 1
+        self.counters['physical lines'] += len(lines)
+
+    def increment_logical_line(self):
+        """Signal a new logical line."""
+        self.counters['logical lines'] += 1
+
+    def error(self, line_number, offset, text, check):
+        """Report an error, according to options."""
+        code = text[:4]
+        if self._ignore_code(code):
+            return
+        if code in self.counters:
+            self.counters[code] += 1
+        else:
+            self.counters[code] = 1
+            self.messages[code] = text[5:]
+        # Don't care about expected errors or warnings
+        if code in self.expected:
+            return
+        if self.print_filename and not self.file_errors:
+            print(self.filename)
+        self.file_errors += 1
+        self.total_errors += 1
+        return code
+
+    def get_file_results(self):
+        """Return the count of errors and warnings for this file."""
+        return self.file_errors
+
+    def get_count(self, prefix=''):
+        """Return the total count of errors and warnings."""
+        return sum([self.counters[key]
+                    for key in self.messages if key.startswith(prefix)])
+
+    def get_statistics(self, prefix=''):
+        """Get statistics for message codes that start with the prefix.
+
+        prefix='' matches all errors and warnings
+        prefix='E' matches all errors
+        prefix='W' matches all warnings
+        prefix='E4' matches all errors that have to do with imports
+        """
+        return ['%-7s %s %s' % (self.counters[key], key, self.messages[key])
+                for key in sorted(self.messages) if key.startswith(prefix)]
+
+    def print_statistics(self, prefix=''):
+        """Print overall statistics (number of errors and warnings)."""
+        for line in self.get_statistics(prefix):
+            print(line)
+
+    def print_benchmark(self):
+        """Print benchmark numbers."""
+        print('%-7.2f %s' % (self.elapsed, 'seconds elapsed'))
+        if self.elapsed:
+            for key in self._benchmark_keys:
+                print('%-7d %s per second (%d total)' %
+                      (self.counters[key] / self.elapsed, key,
+                       self.counters[key]))
+
+
+class FileReport(BaseReport):
+    """Collect the results of the checks and print only the filenames."""
+
+    print_filename = True
+
+
+class StandardReport(BaseReport):
+    """Collect and print the results of the checks."""
+
+    def __init__(self, options):
+        super(StandardReport, self).__init__(options)
+        self._fmt = REPORT_FORMAT.get(options.format.lower(),
+                                      options.format)
+        self._repeat = options.repeat
+        self._show_source = options.show_source
+        self._show_pep8 = options.show_pep8
+
+    def init_file(self, filename, lines, expected, line_offset):
+        """Signal a new file."""
+        self._deferred_print = []
+        return super(StandardReport, self).init_file(
+            filename, lines, expected, line_offset)
+
+    def error(self, line_number, offset, text, check):
+        """Report an error, according to options."""
+        code = super(StandardReport, self).error(line_number, offset,
+                                                 text, check)
+        if code and (self.counters[code] == 1 or self._repeat):
+            self._deferred_print.append(
+                (line_number, offset, code, text[5:], check.__doc__))
+        return code
+
+    def get_file_results(self):
+        """Print the result and return the overall count for this file."""
+        self._deferred_print.sort()
+        for line_number, offset, code, text, doc in self._deferred_print:
+            print(self._fmt % {
+                'path': self.filename,
+                'row': self.line_offset + line_number, 'col': offset + 1,
+                'code': code, 'text': text,
+            })
+            if self._show_source:
+                if line_number > len(self.lines):
+                    line = ''
+                else:
+                    line = self.lines[line_number - 1]
+                print(line.rstrip())
+                print(re.sub(r'\S', ' ', line[:offset]) + '^')
+            if self._show_pep8 and doc:
+                print('    ' + doc.strip())
+
+            # stdout is block buffered when not stdout.isatty().
+            # line can be broken where buffer boundary since other processes
+            # write to same file.
+            # flush() after print() to avoid buffer boundary.
+            # Typical buffer size is 8192. line written safely when
+            # len(line) < 8192.
+            sys.stdout.flush()
+        return self.file_errors
+
+
+class DiffReport(StandardReport):
+    """Collect and print the results for the changed lines only."""
+
+    def __init__(self, options):
+        super(DiffReport, self).__init__(options)
+        self._selected = options.selected_lines
+
+    def error(self, line_number, offset, text, check):
+        if line_number not in self._selected[self.filename]:
+            return
+        return super(DiffReport, self).error(line_number, offset, text, check)
+
+
+class StyleGuide(object):
+    """Initialize a PEP-8 instance with few options."""
+
+    def __init__(self, *args, **kwargs):
+        # build options from the command line
+        self.checker_class = kwargs.pop('checker_class', Checker)
+        parse_argv = kwargs.pop('parse_argv', False)
+        config_file = kwargs.pop('config_file', False)
+        parser = kwargs.pop('parser', None)
+        # build options from dict
+        options_dict = dict(*args, **kwargs)
+        arglist = None if parse_argv else options_dict.get('paths', None)
+        options, self.paths = process_options(
+            arglist, parse_argv, config_file, parser)
+        if options_dict:
+            options.__dict__.update(options_dict)
+            if 'paths' in options_dict:
+                self.paths = options_dict['paths']
+
+        self.runner = self.input_file
+        self.options = options
+
+        if not options.reporter:
+            options.reporter = BaseReport if options.quiet else StandardReport
+
+        options.select = tuple(options.select or ())
+        if not (options.select or options.ignore or
+                options.testsuite or options.doctest) and DEFAULT_IGNORE:
+            # The default choice: ignore controversial checks
+            options.ignore = tuple(DEFAULT_IGNORE.split(','))
+        else:
+            # Ignore all checks which are not explicitly selected
+            options.ignore = ('',) if options.select else tuple(options.ignore)
+        options.benchmark_keys = BENCHMARK_KEYS[:]
+        options.ignore_code = self.ignore_code
+        options.physical_checks = self.get_checks('physical_line')
+        options.logical_checks = self.get_checks('logical_line')
+        options.ast_checks = self.get_checks('tree')
+        self.init_report()
+
+    def init_report(self, reporter=None):
+        """Initialize the report instance."""
+        self.options.report = (reporter or self.options.reporter)(self.options)
+        return self.options.report
+
+    def check_files(self, paths=None):
+        """Run all checks on the paths."""
+        if paths is None:
+            paths = self.paths
+        report = self.options.report
+        runner = self.runner
+        report.start()
+        try:
+            for path in paths:
+                if os.path.isdir(path):
+                    self.input_dir(path)
+                elif not self.excluded(path):
+                    runner(path)
+        except KeyboardInterrupt:
+            print('... stopped')
+        report.stop()
+        return report
+
+    def input_file(self, filename, lines=None, expected=None, line_offset=0):
+        """Run all checks on a Python source file."""
+        if self.options.verbose:
+            print('checking %s' % filename)
+        fchecker = self.checker_class(
+            filename, lines=lines, options=self.options)
+        return fchecker.check_all(expected=expected, line_offset=line_offset)
+
+    def input_dir(self, dirname):
+        """Check all files in this directory and all subdirectories."""
+        dirname = dirname.rstrip('/')
+        if self.excluded(dirname):
+            return 0
+        counters = self.options.report.counters
+        verbose = self.options.verbose
+        filepatterns = self.options.filename
+        runner = self.runner
+        for root, dirs, files in os.walk(dirname):
+            if verbose:
+                print('directory ' + root)
+            counters['directories'] += 1
+            for subdir in sorted(dirs):
+                if self.excluded(subdir, root):
+                    dirs.remove(subdir)
+            for filename in sorted(files):
+                # contain a pattern that matches?
+                if ((filename_match(filename, filepatterns) and
+                     not self.excluded(filename, root))):
+                    runner(os.path.join(root, filename))
+
+    def excluded(self, filename, parent=None):
+        """Check if the file should be excluded.
+
+        Check if 'options.exclude' contains a pattern that matches filename.
+        """
+        if not self.options.exclude:
+            return False
+        basename = os.path.basename(filename)
+        if filename_match(basename, self.options.exclude):
+            return True
+        if parent:
+            filename = os.path.join(parent, filename)
+        filename = os.path.abspath(filename)
+        return filename_match(filename, self.options.exclude)
+
+    def ignore_code(self, code):
+        """Check if the error code should be ignored.
+
+        If 'options.select' contains a prefix of the error code,
+        return False.  Else, if 'options.ignore' contains a prefix of
+        the error code, return True.
+        """
+        if len(code) < 4 and any(s.startswith(code)
+                                 for s in self.options.select):
+            return False
+        return (code.startswith(self.options.ignore) and
+                not code.startswith(self.options.select))
+
+    def get_checks(self, argument_name):
+        """Get all the checks for this category.
+
+        Find all globally visible functions where the first argument name
+        starts with argument_name and which contain selected tests.
+        """
+        checks = []
+        for check, attrs in _checks[argument_name].items():
+            (codes, args) = attrs
+            if any(not (code and self.ignore_code(code)) for code in codes):
+                checks.append((check.__name__, check, args))
+        return sorted(checks)
+
+
+def get_parser(prog='pycodestyle', version=__version__):
+    """Create the parser for the program."""
+    parser = OptionParser(prog=prog, version=version,
+                          usage="%prog [options] input ...")
+    parser.config_options = [
+        'exclude', 'filename', 'select', 'ignore', 'max-line-length',
+        'hang-closing', 'count', 'format', 'quiet', 'show-pep8',
+        'show-source', 'statistics', 'verbose']
+    parser.add_option('-v', '--verbose', default=0, action='count',
+                      help="print status messages, or debug with -vv")
+    parser.add_option('-q', '--quiet', default=0, action='count',
+                      help="report only file names, or nothing with -qq")
+    parser.add_option('-r', '--repeat', default=True, action='store_true',
+                      help="(obsolete) show all occurrences of the same error")
+    parser.add_option('--first', action='store_false', dest='repeat',
+                      help="show first occurrence of each error")
+    parser.add_option('--exclude', metavar='patterns', default=DEFAULT_EXCLUDE,
+                      help="exclude files or directories which match these "
+                           "comma separated patterns (default: %default)")
+    parser.add_option('--filename', metavar='patterns', default='*.py',
+                      help="when parsing directories, only check filenames "
+                           "matching these comma separated patterns "
+                           "(default: %default)")
+    parser.add_option('--select', metavar='errors', default='',
+                      help="select errors and warnings (e.g. E,W6)")
+    parser.add_option('--ignore', metavar='errors', default='',
+                      help="skip errors and warnings (e.g. E4,W) "
+                           "(default: %s)" % DEFAULT_IGNORE)
+    parser.add_option('--show-source', action='store_true',
+                      help="show source code for each error")
+    parser.add_option('--show-pep8', action='store_true',
+                      help="show text of PEP 8 for each error "
+                           "(implies --first)")
+    parser.add_option('--statistics', action='store_true',
+                      help="count errors and warnings")
+    parser.add_option('--count', action='store_true',
+                      help="print total number of errors and warnings "
+                           "to standard error and set exit code to 1 if "
+                           "total is not null")
+    parser.add_option('--max-line-length', type='int', metavar='n',
+                      default=MAX_LINE_LENGTH,
+                      help="set maximum allowed line length "
+                           "(default: %default)")
+    parser.add_option('--hang-closing', action='store_true',
+                      help="hang closing bracket instead of matching "
+                           "indentation of opening bracket's line")
+    parser.add_option('--format', metavar='format', default='default',
+                      help="set the error format [default|pylint|<custom>]")
+    parser.add_option('--diff', action='store_true',
+                      help="report changes only within line number ranges in "
+                           "the unified diff received on STDIN")
+    group = parser.add_option_group("Testing Options")
+    if os.path.exists(TESTSUITE_PATH):
+        group.add_option('--testsuite', metavar='dir',
+                         help="run regression tests from dir")
+        group.add_option('--doctest', action='store_true',
+                         help="run doctest on myself")
+    group.add_option('--benchmark', action='store_true',
+                     help="measure processing speed")
+    return parser
+
+
+def read_config(options, args, arglist, parser):
+    """Read and parse configurations.
+
+    If a config file is specified on the command line with the "--config"
+    option, then only it is used for configuration.
+
+    Otherwise, the user configuration (~/.config/pycodestyle) and any local
+    configurations in the current directory or above will be merged together
+    (in that order) using the read method of ConfigParser.
+    """
+    config = RawConfigParser()
+
+    cli_conf = options.config
+
+    local_dir = os.curdir
+
+    if USER_CONFIG and os.path.isfile(USER_CONFIG):
+        if options.verbose:
+            print('user configuration: %s' % USER_CONFIG)
+        config.read(USER_CONFIG)
+
+    parent = tail = args and os.path.abspath(os.path.commonprefix(args))
+    while tail:
+        if config.read(os.path.join(parent, fn) for fn in PROJECT_CONFIG):
+            local_dir = parent
+            if options.verbose:
+                print('local configuration: in %s' % parent)
+            break
+        (parent, tail) = os.path.split(parent)
+
+    if cli_conf and os.path.isfile(cli_conf):
+        if options.verbose:
+            print('cli configuration: %s' % cli_conf)
+        config.read(cli_conf)
+
+    pycodestyle_section = None
+    if config.has_section(parser.prog):
+        pycodestyle_section = parser.prog
+    elif config.has_section('pep8'):
+        pycodestyle_section = 'pep8'  # Deprecated
+        warnings.warn('[pep8] section is deprecated. Use [pycodestyle].')
+
+    if pycodestyle_section:
+        option_list = dict([(o.dest, o.type or o.action)
+                            for o in parser.option_list])
+
+        # First, read the default values
+        (new_options, __) = parser.parse_args([])
+
+        # Second, parse the configuration
+        for opt in config.options(pycodestyle_section):
+            if opt.replace('_', '-') not in parser.config_options:
+                print("  unknown option '%s' ignored" % opt)
+                continue
+            if options.verbose > 1:
+                print("  %s = %s" % (opt,
+                                     config.get(pycodestyle_section, opt)))
+            normalized_opt = opt.replace('-', '_')
+            opt_type = option_list[normalized_opt]
+            if opt_type in ('int', 'count'):
+                value = config.getint(pycodestyle_section, opt)
+            elif opt_type in ('store_true', 'store_false'):
+                value = config.getboolean(pycodestyle_section, opt)
+            else:
+                value = config.get(pycodestyle_section, opt)
+                if normalized_opt == 'exclude':
+                    value = normalize_paths(value, local_dir)
+            setattr(new_options, normalized_opt, value)
+
+        # Third, overwrite with the command-line options
+        (options, __) = parser.parse_args(arglist, values=new_options)
+    options.doctest = options.testsuite = False
+    return options
+
+
+def process_options(arglist=None, parse_argv=False, config_file=None,
+                    parser=None):
+    """Process options passed either via arglist or via command line args.
+
+    Passing in the ``config_file`` parameter allows other tools, such as flake8
+    to specify their own options to be processed in pycodestyle.
+    """
+    if not parser:
+        parser = get_parser()
+    if not parser.has_option('--config'):
+        group = parser.add_option_group("Configuration", description=(
+            "The project options are read from the [%s] section of the "
+            "tox.ini file or the setup.cfg file located in any parent folder "
+            "of the path(s) being processed.  Allowed options are: %s." %
+            (parser.prog, ', '.join(parser.config_options))))
+        group.add_option('--config', metavar='path', default=config_file,
+                         help="user config file location")
+    # Don't read the command line if the module is used as a library.
+    if not arglist and not parse_argv:
+        arglist = []
+    # If parse_argv is True and arglist is None, arguments are
+    # parsed from the command line (sys.argv)
+    (options, args) = parser.parse_args(arglist)
+    options.reporter = None
+
+    if options.ensure_value('testsuite', False):
+        args.append(options.testsuite)
+    elif not options.ensure_value('doctest', False):
+        if parse_argv and not args:
+            if options.diff or any(os.path.exists(name)
+                                   for name in PROJECT_CONFIG):
+                args = ['.']
+            else:
+                parser.error('input not specified')
+        options = read_config(options, args, arglist, parser)
+        options.reporter = parse_argv and options.quiet == 1 and FileReport
+
+    options.filename = _parse_multi_options(options.filename)
+    options.exclude = normalize_paths(options.exclude)
+    options.select = _parse_multi_options(options.select)
+    options.ignore = _parse_multi_options(options.ignore)
+
+    if options.diff:
+        options.reporter = DiffReport
+        stdin = stdin_get_value()
+        options.selected_lines = parse_udiff(stdin, options.filename, args[0])
+        args = sorted(options.selected_lines)
+
+    return options, args
+
+
+def _parse_multi_options(options, split_token=','):
+    r"""Split and strip and discard empties.
+
+    Turns the following:
+
+    A,
+    B,
+
+    into ["A", "B"]
+    """
+    if options:
+        return [o.strip() for o in options.split(split_token) if o.strip()]
+    else:
+        return options
+
+
+def _main():
+    """Parse options and run checks on Python source."""
+    import signal
+
+    # Handle "Broken pipe" gracefully
+    try:
+        signal.signal(signal.SIGPIPE, lambda signum, frame: sys.exit(1))
+    except AttributeError:
+        pass    # not supported on Windows
+
+    style_guide = StyleGuide(parse_argv=True)
+    options = style_guide.options
+
+    if options.doctest or options.testsuite:
+        from testsuite.support import run_tests
+        report = run_tests(style_guide)
+    else:
+        report = style_guide.check_files()
+
+    if options.statistics:
+        report.print_statistics()
+
+    if options.benchmark:
+        report.print_benchmark()
+
+    if options.testsuite and not options.quiet:
+        report.print_results()
+
+    if report.total_errors:
+        if options.count:
+            sys.stderr.write(str(report.total_errors) + '\n')
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    _main()
diff --git a/kivy/tools/pep8checker/pep8kivy.py b/kivy/tools/pep8checker/pep8kivy.py
new file mode 100644
index 0000000..00a7a33
--- /dev/null
+++ b/kivy/tools/pep8checker/pep8kivy.py
@@ -0,0 +1,109 @@
+import sys
+from os import walk
+from os.path import isdir, join, normpath
+
+import pep8
+
+
+pep8_ignores = (
+    'E125',  # continuation line does not
+             # distinguish itself from next logical line
+    'E126',  # continuation line over-indented for hanging indent
+    'E127',  # continuation line over-indented for visual indent
+    'E128',  # continuation line under-indented for visual indent
+    'E402',  # module level import not at top of file
+    'E741',  # ambiguous variable name
+    'E731',  # do not assign a lambda expression, use a def
+    'W503',  # allow putting binary operators after line split
+)
+
+
+class KivyStyleChecker(pep8.Checker):
+
+    def __init__(self, filename):
+        pep8.Checker.__init__(self, filename, ignore=pep8_ignores)
+
+    def report_error(self, line_number, offset, text, check):
+        return pep8.Checker.report_error(
+            self, line_number, offset, text, check)
+
+
+if __name__ == '__main__':
+    print("DEPRECATED: Use pre-commit.com framework instead: ",
+          "pip install pre-commit && make hook")
+
+    def usage():
+        print('Usage: python pep8kivy.py <file_or_folder_to_check>*')
+        print('Folders will be checked recursively.')
+        sys.exit(1)
+
+    if len(sys.argv) < 2:
+        usage()
+    elif sys.argv == 2:
+        targets = sys.argv[-1]
+    else:
+        targets = sys.argv[-1].split()
+
+    def check(fn):
+        try:
+            checker = KivyStyleChecker(fn)
+        except IOError:
+            # File couldn't be opened, so was deleted apparently.
+            # Don't check deleted files.
+            return 0
+        return checker.check_all()
+
+    errors = 0
+
+    exclude_dirs = [
+        'kivy/lib',
+        'kivy/deps',
+        'kivy/tools/pep8checker',
+        'coverage',
+        'doc'
+    ]
+    exclude_dirs = [normpath(i) for i in exclude_dirs]
+    exclude_files = [
+        'kivy/gesture.py',
+        'kivy/tools/stub-gl-debug.py',
+        'kivy/modules/webdebugger.py',
+        'kivy/modules/_webdebugger.py'
+    ]
+    exclude_files = [normpath(i) for i in exclude_files]
+
+    for target in targets:
+        if isdir(target):
+            for dirpath, dirnames, filenames in walk(target):
+                cont = False
+                dpath = normpath(dirpath)
+                for pat in exclude_dirs:
+                    if dpath.startswith(pat):
+                        cont = True
+                        break
+                if cont:
+                    continue
+                for filename in filenames:
+                    if not filename.endswith('.py'):
+                        continue
+                    cont = False
+                    complete_filename = join(dirpath, filename)
+                    for pat in exclude_files:
+                        if complete_filename.endswith(pat):
+                            cont = True
+                    if cont:
+                        continue
+
+                    errors += check(complete_filename)
+
+        else:
+            # Got a single file to check
+            for pat in exclude_dirs + exclude_files:
+                if pat in target:
+                    break
+            else:
+                if target.endswith('.py'):
+                    errors += check(target)
+
+    if errors:
+        print("Error: {} style guide violation(s) encountered.".format(errors))
+        sys.exit(1)
diff --git a/kivy/tools/pep8checker/pre-commit.githook b/kivy/tools/pep8checker/pre-commit.githook
new file mode 100755
index 0000000..f84c274
--- /dev/null
+++ b/kivy/tools/pep8checker/pre-commit.githook
@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+'''
+    Kivy Git Pre-Commit Hook to Enforce Styleguide
+    ==============================================
+
+    DEPRECATED: Use pre-commit.com framework instead:
+    `pip install pre-commit && make hook`
+
+    This script is not supposed to be run directly.
+    Instead, copy it to your kivy/.git/hooks/ directory, call it 'pre-commit'
+    and make it executable.
+
+    If you attempt to commit, git will run this script, which in turn will run
+    the styleguide checker over your code and abort the commit if there are any
+    errors. If that happens, please fix & retry.
+
+    To install::
+
+        cp kivy/tools/pep8checker/pre-commit.githook .git/hooks/pre-commit
+        chmod +x .git/hooks/pre-commit
+'''
+
+import os
+import sys
+from os.path import dirname, abspath, sep, join
+from subprocess import call, Popen, PIPE
+
+curdir = dirname(abspath(__file__))
+kivydir = sep.join(curdir.split(sep)[:-2])
+srcdir = join(kivydir, 'kivy')
+script = join(srcdir, 'tools', 'pep8checker', 'pep8kivy.py')
+try:
+    with open(script):
+        pass
+except IOError:
+    # if this not the kivy project, find the script file in the kivy project
+    os.environ['KIVY_NO_CONSOLELOG'] = '1'
+    import kivy
+    script = join(dirname(kivy.__file__), 'tools', 'pep8checker', 'pep8kivy.py')
+    srcdir = ''
+
+# Only check the files that were staged
+# proc = Popen(['git', 'diff', '--cached', '--name-only', 'HEAD'], stdout=PIPE)
+# targets = [join(kivydir, target) for target in proc.stdout]
+
+# Correction: only check the files that were staged, but do not include
+# deleted files.
+proc = Popen(['git', 'diff', '--cached', '--name-status', 'HEAD'], stdout=PIPE)
+proc.wait()
+
+# This gives output like the following:
+#
+#    A       examples/widgets/lists/list_simple_in_kv.py
+#    A       examples/widgets/lists/list_simple_in_kv_2.py
+#    D       kivy/uix/observerview.py
+#
+# So check for D entries and remove them from targets.
+#
+targets = []
+for target in proc.stdout:
+    parts = [p.strip() for p in target.split()]
+    if parts[0] != 'D':
+        targets.append(join(kivydir, target.decode(encoding='UTF-8')))
+
+# Untested possibility: After making the changes above for removing deleted
+# files from targets, saw also where the git diff call could be:
+#
+#    git diff --cached --name-only --diff-filter=ACM
+#                                                    (leaving off D)
+#
+# and we could then remove the special handling in python for targets above.
+
+call(['git', 'stash', 'save', '--keep-index', '--quiet'])
+retval = call([sys.executable, script, srcdir] + targets)
+call(['git', 'stash', 'pop', '--quiet'])
+
+if retval:
+    # There are style guide violations
+    print("Your commit has been aborted. Please fix the violations and retry.")
+    sys.exit(1)
diff --git a/kivy/tools/precommit_hooks/pre-commit-config.yaml b/kivy/tools/precommit_hooks/pre-commit-config.yaml
new file mode 100644
index 0000000..b9c5849
--- /dev/null
+++ b/kivy/tools/precommit_hooks/pre-commit-config.yaml
@@ -0,0 +1,34 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+default_language_version:
+    python: python3
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.0.1
+    hooks:
+    -   id: no-commit-to-branch
+    -   id: check-executables-have-shebangs
+    -   id: check-ast
+    -   id: check-merge-conflict
+    -   id: check-toml
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+    -   id: check-case-conflict
+    -   id: check-json
+    -   id: check-symlinks
+    -   id: pretty-format-json
+        args:
+        - --autofix
+-   repo: https://gitlab.com/pycqa/flake8
+    rev: 3.8.4
+    hooks:
+    -   id: flake8
+-   repo: https://github.com/Lucas-C/pre-commit-hooks
+    rev: v1.1.7
+    hooks:
+    -   id: forbid-crlf
+    -   id: remove-crlf
+    -   id: forbid-tabs
+    -   id: remove-tabs
diff --git a/kivy/tools/report.py b/kivy/tools/report.py
new file mode 100644
index 0000000..095d2b1
--- /dev/null
+++ b/kivy/tools/report.py
@@ -0,0 +1,223 @@
+'''
+Report tool
+===========
+
+This tool is a helper for users. It can be used to dump information
+for help during the debugging process.
+
+'''
+
+import os
+import sys
+import platform as plf
+from time import ctime
+from configparser import ConfigParser
+from io import StringIO
+
+import kivy
+
+report = []
+report_dict = {}  # One key value pair for each title.
+
+
+def title(t):
+    report.append('')
+    report.append('=' * 80)
+    report.append(t)
+    report.append('=' * 80)
+    report.append('')
+
+# This method sends report to gist(Different file in a single gist) and
+# returns the URL
+
+
+def send_report(dict_report):
+    import requests
+    import json
+
+    gist_report = {
+        "description": "Report",
+        "public": "true",
+        "files": {
+            "Global.txt": {
+                "content": "\n".join(dict_report['Global']),
+                "type": 'text'
+            },
+            "OpenGL.txt": {
+                "content": "\n".join(dict_report['OpenGL']),
+                "type": 'text'
+
+            },
+            "Core selection.txt": {
+                "content": "\n".join(dict_report['Core']),
+                "type": 'text'
+            },
+            "Libraries.txt": {
+                "content": "\n".join(dict_report['Libraries']),
+                "type": 'text'
+            },
+            "Configuration.txt": {
+                "content": "\n".join(dict_report['Configuration']),
+                "type": 'text'
+            },
+            "Input Availability.txt": {
+                "content": "\n".join(dict_report['InputAvailability']),
+                "type": 'text'
+            },
+            "Environ.txt": {
+                "content": "\n".join(dict_report['Environ']),
+                "type": 'text'
+            },
+            "Options.txt": {
+                "content": "\n".join(dict_report['Options']),
+                "type": 'text'
+            },
+        }
+    }
+    report_json = json.dumps(gist_report)
+    response = requests.post("https://api.github.com/gists", report_json)
+    return json.loads(response.text)['html_url']
+
+# ----------------------------------------------------------
+# Start output debugging
+# ----------------------------------------------------------
+
+
+title('Global')
+report.append('OS platform     : %s | %s' % (plf.platform(), plf.machine()))
+report.append('Python EXE      : %s' % sys.executable)
+report.append('Python Version  : %s' % sys.version)
+report.append('Python API      : %s' % sys.api_version)
+report.append('Kivy Version    : %s' % kivy.__version__)
+report.append('Install path    : %s' % os.path.dirname(kivy.__file__))
+report.append('Install date    : %s' % ctime(os.path.getctime(kivy.__file__)))
+report_dict['Global'] = report
+report = []
+
+title('OpenGL')
+from kivy.core import gl
+from kivy.core.window import Window
+report.append('GL Vendor: %s' % gl.glGetString(gl.GL_VENDOR))
+report.append('GL Renderer: %s' % gl.glGetString(gl.GL_RENDERER))
+report.append('GL Version: %s' % gl.glGetString(gl.GL_VERSION))
+ext = None
+try:
+    gl.glGetString(gl.GL_EXTENSIONS)
+except AttributeError:
+    pass
+if ext is None:
+    report.append('GL Extensions: %s' % ext)
+else:
+    report.append('GL Extensions:')
+    for x in ext.split():
+        report.append('\t%s' % x)
+Window.close()
+report_dict['OpenGL'] = report
+report = []
+
+title('Core selection')
+from kivy.core.audio import SoundLoader
+report.append('Audio  = %s' % SoundLoader._classes)
+from kivy.core.camera import Camera
+report.append('Camera = %s' % Camera)
+from kivy.core.image import ImageLoader
+report.append('Image  = %s' % ImageLoader.loaders)
+from kivy.core.text import Label
+report.append('Text   = %s' % Label)
+from kivy.core.video import Video
+report.append('Video  = %s' % Video)
+report.append('Window = %s' % Window)
+report_dict['Core'] = report
+report = []
+
+title('Libraries')
+
+
+def testimport(libname):
+    try:
+        lib = __import__(libname)
+        report.append('%-20s exist at %s' % (libname, lib.__file__))
+    except ImportError:
+        report.append('%-20s is missing' % libname)
+
+
+for x in ('gst',
+          'pygame',
+          'pygame.midi',
+          'squirtle',
+          'PIL',
+          'sdl2',
+          'glew',
+          'opencv',
+          'opencv.cv',
+          'opencv.highgui',
+          'cython'):
+    testimport(x)
+report_dict['Libraries'] = report
+report = []
+
+title('Configuration')
+s = StringIO()
+from kivy.config import Config
+ConfigParser.write(Config, s)
+report.extend(s.getvalue().split('\n'))
+report_dict['Configuration'] = report
+report = []
+
+title('Input availability')
+from kivy.input.factory import MotionEventFactory
+for x in MotionEventFactory.list():
+    report.append(x)
+report_dict['InputAvailability'] = report
+report = []
+
+'''
+title('Log')
+for x in pymt_logger_history.history:
+    report.append(x.message)
+'''
+
+title('Environ')
+for k, v in os.environ.items():
+    report.append('%s = %s' % (k, v))
+report_dict['Environ'] = report
+report = []
+
+title('Options')
+for k, v in kivy.kivy_options.items():
+    report.append('%s = %s' % (k, v))
+report_dict['Options'] = report
+report = []
+
+# Prints the entire Output
+print('\n'.join(report_dict['Global'] + report_dict['OpenGL'] +
+                report_dict['Core'] + report_dict['Libraries'] +
+                report_dict['Configuration'] +
+                report_dict['InputAvailability'] +
+                report_dict['Environ'] + report_dict['Options']))
+print('\n')
+print('\n')
+
+try:
+    print('The report will be sent as an anonymous gist.')
+    reply = input(
+        'Do you accept to send report to https://gist.github.com/ (Y/n) : ')
+except EOFError:
+    sys.exit(0)
+
+if reply.lower().strip() in ('', 'y'):
+    print('Please wait while sending the report...')
+
+    paste_url = send_report(report_dict)
+
+    print('\n')
+    print('\n')
+    print('REPORT posted at %s' % paste_url)
+    print('\n')
+    print('\n')
+else:
+    print('No report posted.')
+
+# On windows system, the console leave directly after the end
+# of the dump. That's not cool if we want get report url
+input('Enter any key to leave.')
diff --git a/kivy/tools/stub-gl-debug.py b/kivy/tools/stub-gl-debug.py
new file mode 100644
index 0000000..4d44522
--- /dev/null
+++ b/kivy/tools/stub-gl-debug.py
@@ -0,0 +1,201 @@
+# flake8: noqa
+from __future__ import print_function
+
+a = '''cdef void   glActiveTexture (cgl.GLenum texture)
+cdef void   glAttachShader (cgl.GLuint program, cgl.GLuint shader)
+cdef void   glBindAttribLocation (cgl.GLuint program, cgl.GLuint index,  cgl.GLchar* name)
+cdef void   glBindBuffer (cgl.GLenum target, cgl.GLuint buffer)
+cdef void   glBindFramebuffer (cgl.GLenum target, cgl.GLuint framebuffer)
+cdef void   glBindRenderbuffer (cgl.GLenum target, cgl.GLuint renderbuffer)
+cdef void   glBindTexture (cgl.GLenum target, cgl.GLuint texture)
+cdef void   glBlendColor (cgl.GLclampf red, cgl.GLclampf green, cgl.GLclampf blue, cgl.GLclampf alpha)
+cdef void   glBlendEquation (cgl.GLenum mode)
+cdef void   glBlendEquationSeparate (cgl.GLenum modeRGB, cgl.GLenum modeAlpha)
+cdef void   glBlendFunc (cgl.GLenum sfactor, cgl.GLenum dfactor)
+cdef void   glBlendFuncSeparate (cgl.GLenum srcRGB, cgl.GLenum dstRGB, cgl.GLenum srcAlpha, cgl.GLenum dstAlpha)
+cdef void   glBufferData (cgl.GLenum target, cgl.GLsizeiptr size,  cgl.GLvoid* data, cgl.GLenum usage)
+cdef void   glBufferSubData (cgl.GLenum target, cgl.GLintptr offset, cgl.GLsizeiptr size,  cgl.GLvoid* data)
+cdef cgl.GLenum glCheckFramebufferStatus (cgl.GLenum target)
+cdef void   glClear (cgl.GLbitfield mask)
+cdef void   glClearColor (cgl.GLclampf red, cgl.GLclampf green, cgl.GLclampf blue, cgl.GLclampf alpha)
+cdef void   glClearDepthf (cgl.GLclampf depth)
+cdef void   glClearStencil (cgl.GLint s)
+cdef void   glColorMask (cgl.GLboolean red, cgl.GLboolean green, cgl.GLboolean blue, cgl.GLboolean alpha)
+cdef void   glCompileShader (cgl.GLuint shader)
+cdef void   glCompressedTexImage2D (cgl.GLenum target, cgl.GLint level, cgl.GLenum internalformat, cgl.GLsizei width, cgl.GLsizei height, cgl.GLint border, cgl.GLsizei imageSize,  cgl.GLvoid* data)
+cdef void   glCompressedTexSubImage2D (cgl.GLenum target, cgl.GLint level, cgl.GLint xoffset, cgl.GLint yoffset, cgl.GLsizei width, cgl.GLsizei height, cgl.GLenum format, cgl.GLsizei imageSize,  cgl.GLvoid* data)
+cdef void   glCopyTexImage2D (cgl.GLenum target, cgl.GLint level, cgl.GLenum internalformat, cgl.GLint x, cgl.GLint y, cgl.GLsizei width, cgl.GLsizei height, cgl.GLint border)
+cdef void   glCopyTexSubImage2D (cgl.GLenum target, cgl.GLint level, cgl.GLint xoffset, cgl.GLint yoffset, cgl.GLint x, cgl.GLint y, cgl.GLsizei width, cgl.GLsizei height)
+cdef cgl.GLuint glCreateProgram ()
+cdef cgl.GLuint glCreateShader (cgl.GLenum type)
+cdef void   glCullFace (cgl.GLenum mode)
+cdef void   glDeleteBuffers (cgl.GLsizei n,  cgl.GLuint* buffers)
+cdef void   glDeleteFramebuffers (cgl.GLsizei n,  cgl.GLuint* framebuffers)
+cdef void   glDeleteProgram (cgl.GLuint program)
+cdef void   glDeleteRenderbuffers (cgl.GLsizei n,  cgl.GLuint* renderbuffers)
+cdef void   glDeleteShader (cgl.GLuint shader)
+cdef void   glDeleteTextures (cgl.GLsizei n,  cgl.GLuint* textures)
+cdef void   glDepthFunc (cgl.GLenum func)
+cdef void   glDepthMask (cgl.GLboolean flag)
+cdef void   glDepthRangef (cgl.GLclampf zNear, cgl.GLclampf zFar)
+cdef void   glDetachShader (cgl.GLuint program, cgl.GLuint shader)
+cdef void   glDisable (cgl.GLenum cap)
+cdef void   glDisableVertexAttribArray (cgl.GLuint index)
+cdef void   glDrawArrays (cgl.GLenum mode, cgl.GLint first, cgl.GLsizei count)
+cdef void   glDrawElements (cgl.GLenum mode, cgl.GLsizei count, cgl.GLenum type,  cgl.GLvoid* indices)
+cdef void   glEnable (cgl.GLenum cap)
+cdef void   glEnableVertexAttribArray (cgl.GLuint index)
+cdef void   glFinish ()
+cdef void   glFlush ()
+cdef void   glFramebufferRenderbuffer (cgl.GLenum target, cgl.GLenum attachment, cgl.GLenum renderbuffertarget, cgl.GLuint renderbuffer)
+cdef void   glFramebufferTexture2D (cgl.GLenum target, cgl.GLenum attachment, cgl.GLenum textarget, cgl.GLuint texture, cgl.GLint level)
+cdef void   glFrontFace (cgl.GLenum mode)
+cdef void   glGenBuffers (cgl.GLsizei n, cgl.GLuint* buffers)
+cdef void   glGenerateMipmap (cgl.GLenum target)
+cdef void   glGenFramebuffers (cgl.GLsizei n, cgl.GLuint* framebuffers)
+cdef void   glGenRenderbuffers (cgl.GLsizei n, cgl.GLuint* renderbuffers)
+cdef void   glGenTextures (cgl.GLsizei n, cgl.GLuint* textures)
+cdef void   glGetActiveAttrib (cgl.GLuint program, cgl.GLuint index, cgl.GLsizei bufsize, cgl.GLsizei* length, cgl.GLint* size, cgl.GLenum* type, cgl.GLchar* name)
+cdef void   glGetActiveUniform (cgl.GLuint program, cgl.GLuint index, cgl.GLsizei bufsize, cgl.GLsizei* length, cgl.GLint* size, cgl.GLenum* type, cgl.GLchar* name)
+cdef void   glGetAttachedShaders (cgl.GLuint program, cgl.GLsizei maxcount, cgl.GLsizei* count, cgl.GLuint* shaders)
+cdef int    glGetAttribLocation (cgl.GLuint program,  cgl.GLchar* name)
+cdef void   glGetBooleanv (cgl.GLenum pname, cgl.GLboolean* params)
+cdef void   glGetBufferParameteriv (cgl.GLenum target, cgl.GLenum pname, cgl.GLint* params)
+cdef cgl.GLenum glGetError ()
+cdef void   glGetFloatv (cgl.GLenum pname, cgl.GLfloat* params)
+cdef void   glGetFramebufferAttachmentParameteriv (cgl.GLenum target, cgl.GLenum attachment, cgl.GLenum pname, cgl.GLint* params)
+cdef void   glGetIntegerv (cgl.GLenum pname, cgl.GLint* params)
+cdef void   glGetProgramiv (cgl.GLuint program, cgl.GLenum pname, cgl.GLint* params)
+cdef void   glGetProgramInfoLog (cgl.GLuint program, cgl.GLsizei bufsize, cgl.GLsizei* length, cgl.GLchar* infolog)
+cdef void   glGetRenderbufferParameteriv (cgl.GLenum target, cgl.GLenum pname, cgl.GLint* params)
+cdef void   glGetShaderiv (cgl.GLuint shader, cgl.GLenum pname, cgl.GLint* params)
+cdef void   glGetShaderInfoLog (cgl.GLuint shader, cgl.GLsizei bufsize, cgl.GLsizei* length, cgl.GLchar* infolog)
+#cdef void   glGetShaderPrecisionFormat (cgl.GLenum shadertype, cgl.GLenum precisiontype, cgl.GLint* range, cgl.GLint* precision)
+cdef void   glGetShaderSource (cgl.GLuint shader, cgl.GLsizei bufsize, cgl.GLsizei* length, cgl.GLchar* source)
+cdef   cgl.GLubyte*  glGetString (cgl.GLenum name)
+cdef void   glGetTexParameterfv (cgl.GLenum target, cgl.GLenum pname, cgl.GLfloat* params)
+cdef void   glGetTexParameteriv (cgl.GLenum target, cgl.GLenum pname, cgl.GLint* params)
+cdef void   glGetUniformfv (cgl.GLuint program, cgl.GLint location, cgl.GLfloat* params)
+cdef void   glGetUniformiv (cgl.GLuint program, cgl.GLint location, cgl.GLint* params)
+cdef int    glGetUniformLocation (cgl.GLuint program,  cgl.GLchar* name)
+cdef void   glGetVertexAttribfv (cgl.GLuint index, cgl.GLenum pname, cgl.GLfloat* params)
+cdef void   glGetVertexAttribiv (cgl.GLuint index, cgl.GLenum pname, cgl.GLint* params)
+cdef void   glGetVertexAttribPointerv (cgl.GLuint index, cgl.GLenum pname, cgl.GLvoid** pointer)
+cdef void   glHint (cgl.GLenum target, cgl.GLenum mode)
+cdef cgl.GLboolean  glIsBuffer (cgl.GLuint buffer)
+cdef cgl.GLboolean  glIsEnabled (cgl.GLenum cap)
+cdef cgl.GLboolean  glIsFramebuffer (cgl.GLuint framebuffer)
+cdef cgl.GLboolean  glIsProgram (cgl.GLuint program)
+cdef cgl.GLboolean  glIsRenderbuffer (cgl.GLuint renderbuffer)
+cdef cgl.GLboolean  glIsShader (cgl.GLuint shader)
+cdef cgl.GLboolean  glIsTexture (cgl.GLuint texture)
+cdef void  glLineWidth (cgl.GLfloat width)
+cdef void  glLinkProgram (cgl.GLuint program)
+cdef void  glPixelStorei (cgl.GLenum pname, cgl.GLint param)
+cdef void  glPolygonOffset (cgl.GLfloat factor, cgl.GLfloat units)
+cdef void  glReadPixels (cgl.GLint x, cgl.GLint y, cgl.GLsizei width, cgl.GLsizei height, cgl.GLenum format, cgl.GLenum type, cgl.GLvoid* pixels)
+#cdef void  glReleaseShaderCompiler ()
+cdef void  glRenderbufferStorage (cgl.GLenum target, cgl.GLenum internalformat, cgl.GLsizei width, cgl.GLsizei height)
+cdef void  glSampleCoverage (cgl.GLclampf value, cgl.GLboolean invert)
+cdef void  glScissor (cgl.GLint x, cgl.GLint y, cgl.GLsizei width, cgl.GLsizei height)
+#cdef void  glShaderBinary (cgl.GLsizei n,  cgl.GLuint* shaders, cgl.GLenum binaryformat,  cgl.GLvoid* binary, cgl.GLsizei length)
+cdef void  glShaderSource (cgl.GLuint shader, cgl.GLsizei count,  cgl.GLchar** string,  cgl.GLint* length)
+cdef void  glStencilFunc (cgl.GLenum func, cgl.GLint ref, cgl.GLuint mask)
+cdef void  glStencilFuncSeparate (cgl.GLenum face, cgl.GLenum func, cgl.GLint ref, cgl.GLuint mask)
+cdef void  glStencilMask (cgl.GLuint mask)
+cdef void  glStencilMaskSeparate (cgl.GLenum face, cgl.GLuint mask)
+cdef void  glStencilOp (cgl.GLenum fail, cgl.GLenum zfail, cgl.GLenum zpass)
+cdef void  glStencilOpSeparate (cgl.GLenum face, cgl.GLenum fail, cgl.GLenum zfail, cgl.GLenum zpass)
+cdef void  glTexImage2D (cgl.GLenum target, cgl.GLint level, cgl.GLint internalformat, cgl.GLsizei width, cgl.GLsizei height, cgl.GLint border, cgl.GLenum format, cgl.GLenum type,  cgl.GLvoid* pixels)
+cdef void  glTexParameterf (cgl.GLenum target, cgl.GLenum pname, cgl.GLfloat param)
+cdef void  glTexParameterfv (cgl.GLenum target, cgl.GLenum pname,  cgl.GLfloat* params)
+cdef void  glTexParameteri (cgl.GLenum target, cgl.GLenum pname, cgl.GLint param)
+cdef void  glTexParameteriv (cgl.GLenum target, cgl.GLenum pname,  cgl.GLint* params)
+cdef void  glTexSubImage2D (cgl.GLenum target, cgl.GLint level, cgl.GLint xoffset, cgl.GLint yoffset, cgl.GLsizei width, cgl.GLsizei height, cgl.GLenum format, cgl.GLenum type,  cgl.GLvoid* pixels)
+cdef void  glUniform1f (cgl.GLint location, cgl.GLfloat x)
+cdef void  glUniform1fv (cgl.GLint location, cgl.GLsizei count,  cgl.GLfloat* v)
+cdef void  glUniform1i (cgl.GLint location, cgl.GLint x)
+cdef void  glUniform1iv (cgl.GLint location, cgl.GLsizei count,  cgl.GLint* v)
+cdef void  glUniform2f (cgl.GLint location, cgl.GLfloat x, cgl.GLfloat y)
+cdef void  glUniform2fv (cgl.GLint location, cgl.GLsizei count,  cgl.GLfloat* v)
+cdef void  glUniform2i (cgl.GLint location, cgl.GLint x, cgl.GLint y)
+cdef void  glUniform2iv (cgl.GLint location, cgl.GLsizei count,  cgl.GLint* v)
+cdef void  glUniform3f (cgl.GLint location, cgl.GLfloat x, cgl.GLfloat y, cgl.GLfloat z)
+cdef void  glUniform3fv (cgl.GLint location, cgl.GLsizei count,  cgl.GLfloat* v)
+cdef void  glUniform3i (cgl.GLint location, cgl.GLint x, cgl.GLint y, cgl.GLint z)
+cdef void  glUniform3iv (cgl.GLint location, cgl.GLsizei count,  cgl.GLint* v)
+cdef void  glUniform4f (cgl.GLint location, cgl.GLfloat x, cgl.GLfloat y, cgl.GLfloat z, cgl.GLfloat w)
+cdef void  glUniform4fv (cgl.GLint location, cgl.GLsizei count,  cgl.GLfloat* v)
+cdef void  glUniform4i (cgl.GLint location, cgl.GLint x, cgl.GLint y, cgl.GLint z, cgl.GLint w)
+cdef void  glUniform4iv (cgl.GLint location, cgl.GLsizei count,  cgl.GLint* v)
+cdef void  glUniformMatrix2fv (cgl.GLint location, cgl.GLsizei count, cgl.GLboolean transpose,  cgl.GLfloat* value)
+cdef void  glUniformMatrix3fv (cgl.GLint location, cgl.GLsizei count, cgl.GLboolean transpose,  cgl.GLfloat* value)
+cdef void  glUniformMatrix4fv (cgl.GLint location, cgl.GLsizei count, cgl.GLboolean transpose,  cgl.GLfloat* value)
+cdef void  glUseProgram (cgl.GLuint program)
+cdef void  glValidateProgram (cgl.GLuint program)
+cdef void  glVertexAttrib1f (cgl.GLuint indx, cgl.GLfloat x)
+cdef void  glVertexAttrib1fv (cgl.GLuint indx,  cgl.GLfloat* values)
+cdef void  glVertexAttrib2f (cgl.GLuint indx, cgl.GLfloat x, cgl.GLfloat y)
+cdef void  glVertexAttrib2fv (cgl.GLuint indx,  cgl.GLfloat* values)
+cdef void  glVertexAttrib3f (cgl.GLuint indx, cgl.GLfloat x, cgl.GLfloat y, cgl.GLfloat z)
+cdef void  glVertexAttrib3fv (cgl.GLuint indx,  cgl.GLfloat* values)
+cdef void  glVertexAttrib4f (cgl.GLuint indx, cgl.GLfloat x, cgl.GLfloat y, cgl.GLfloat z, cgl.GLfloat w)
+cdef void  glVertexAttrib4fv (cgl.GLuint indx,  cgl.GLfloat* values)
+cdef void  glVertexAttribPointer (cgl.GLuint indx, cgl.GLint size, cgl.GLenum type, cgl.GLboolean normalized, cgl.GLsizei stride,  cgl.GLvoid* ptr)
+cdef void  glViewport (cgl.GLint x, cgl.GLint y, cgl.GLsizei width, cgl.GLsizei height)'''
+
+def replace(s):
+    item = s.split(' ')
+    rettype = item[1]
+    item = item[2:]
+    for x in item:
+        x = x.strip()
+        if not x or x.startswith('GL'):
+            continue
+        if x.startswith('(GL'):
+            yield '('
+            continue
+        if x.startswith('gl'):
+            prefix = ''
+            if rettype != 'void':
+                prefix = 'return '
+            yield '%scgl.%s' % (prefix, x)
+            continue
+        yield x
+
+print('''
+# This file was automatically generated with kivy/tools/stub-gl-debug.py
+cimport c_opengl as cgl
+
+''')
+
+lines = a.splitlines()
+for x in lines:
+    if x.startswith('#'):
+        # There are some functions that either do not exist or break on OSX.
+        # Just skip those.
+        print('# Skipping generation of: "%s"' % x)
+        continue
+    x = x.replace('cgl.', '')
+    y = ' '.join(replace(x))
+
+    print('%s with gil:' % x)
+    s = x.split()
+    print('    print("GL %s(' % s[2], end=' ')
+    pointer = 0
+    for arg in s[3:]:
+        arg = arg.strip()
+        arg = arg.replace(',', '').replace(')', '')
+        if 'GL' in arg or arg == '(':
+            pointer = arg.count('*')
+            continue
+        pointer = '*' * pointer
+        if pointer:
+            print('%s%s=", repr(hex(<long> %s)), ",' % (arg, pointer, arg), end=' ')
+        else:
+            print('%s = ", %s, ",' % (arg, arg), end=' ')
+        pointer = 0
+    print(')")')
+    print('    %s' % y)
+    print('    ret = glGetError()')
+    print('    if ret: print("ERR {} / {}".format(ret, ret))')
diff --git a/kivy/tools/texturecompress.py b/kivy/tools/texturecompress.py
new file mode 100644
index 0000000..4a440bc
--- /dev/null
+++ b/kivy/tools/texturecompress.py
@@ -0,0 +1,233 @@
+'''
+Texture compression tool
+========================
+
+This tool is designed to compress images into:
+
+- PVRTC (PowerVR Texture Compression), mostly iOS devices
+- ETC1 (Ericson compression), working on all GLES2/Android devices
+
+Usage
+-----
+
+In order to compress a texture::
+
+    texturecompress.py [--dir <directory>] <format> <image.png>
+
+This will create a `image.tex` file with a json header that contains all the
+image information and the compressed data.
+
+TODO
+----
+
+Support more format, such as:
+
+- S3TC (already supported in Kivy)
+- DXT1 (already supported in Kivy)
+'''
+
+import json
+from struct import pack
+from pprint import pprint
+from subprocess import Popen
+from PIL import Image
+from argparse import ArgumentParser
+from sys import exit
+from os.path import join, exists, dirname, basename
+from os import environ, unlink
+
+
+class Tool(object):
+    def __init__(self, options):
+        super(Tool, self).__init__()
+        self.options = options
+        self.source_fn = options.image
+        self.dest_dir = options.dir or dirname(options.image)
+
+    @property
+    def tex_fn(self):
+        fn = basename(self.source_fn).rsplit('.', 1)[0] + '.tex'
+        return join(self.dest_dir, fn)
+
+    def compress(self):
+        pass
+
+    def nearest_pow2(self, v):
+        # Credits: Sean Anderson
+        v -= 1
+        v |= v >> 1
+        v |= v >> 2
+        v |= v >> 4
+        v |= v >> 8
+        v |= v >> 16
+        return v + 1
+
+    def runcmd(self, cmd):
+        print('Run: {}'.format(' '.join(cmd)))
+        Popen(cmd).communicate()
+
+    def write_tex(self, data, fmt, image_size, texture_size, mipmap=False,
+            formatinfo=None):
+        infos = {
+            'datalen': len(data),
+            'image_size': image_size,
+            'texture_size': texture_size,
+            'mipmap': mipmap,
+            'format': fmt}
+        if formatinfo:
+            infos['formatinfo'] = formatinfo
+        header = json.dumps(infos, indent=0, separators=(',', ':'))
+        header = header.replace('\n', '')
+        with open(self.tex_fn, 'wb') as fd:
+            fd.write('KTEX')
+            fd.write(pack('I', len(header)))
+            fd.write(header)
+            fd.write(data)
+
+        print('Done! Compressed texture written at {}'.format(self.tex_fn))
+        pprint(infos)
+
+    @staticmethod
+    def run():
+        parser = ArgumentParser(
+                description='Convert images to compressed texture')
+        parser.add_argument('--mipmap', type=bool, default=False,
+                help='Auto generate mipmaps')
+        parser.add_argument('--dir', type=str, default=None,
+                help='Output directory to generate the compressed texture')
+        parser.add_argument('format', type=str, choices=['pvrtc', 'etc1'],
+                help='Format of the final texture')
+        parser.add_argument('image', type=str,
+                help='Image filename')
+        args = parser.parse_args()
+
+        if args.format == 'pvrtc':
+            PvrtcTool(args).compress()
+        elif args.format == 'etc1':
+            Etc1Tool(args).compress()
+        else:
+            print('Unknown compression format')
+            exit(1)
+
+
+class Etc1Tool(Tool):
+    def __init__(self, options):
+        super(Etc1Tool, self).__init__(options)
+        self.etc1tool = None
+        self.locate_etc1tool()
+
+    def locate_etc1tool(self):
+        search_directories = [environ.get('ANDROIDSDK', '/')]
+        search_directories += environ.get('PATH', '').split(':')
+        for directory in search_directories:
+            fn = join(directory, 'etc1tool')
+            if not exists(fn):
+                fn = join(directory, 'tools', 'etc1tool')
+                if not exists(fn):
+                    continue
+            print('Found texturetool at {}'.format(directory))
+            self.etc1tool = fn
+            return
+
+        if self.etc1tool is None:
+            print('Error: Unable to locate "etc1tool".\n'
+                  'Make sure that "etc1tool" is available in your PATH.\n'
+                  'Or export the path of your Android SDK to ANDROIDSDK')
+            exit(1)
+
+    def compress(self):
+        # 1. open the source image, and get the dimensions
+        image = Image.open(self.source_fn)
+        w, h = image.size
+        print('Image size is {}x{}'.format(*image.size))
+
+        # 2. search the nearest 2^
+        w2 = self.nearest_pow2(w)
+        h2 = self.nearest_pow2(h)
+        print('Nearest power-of-2 size is {}x{}'.format(w2, h2))
+
+        # 3. invoke etc1tool
+        raw_tex_fn = self.tex_fn + '.raw'
+        cmd = [self.etc1tool, self.source_fn, '--encodeNoHeader', '-o',
+               raw_tex_fn]
+        try:
+            self.runcmd(cmd)
+            with open(raw_tex_fn, 'rb') as fd:
+                data = fd.read()
+        finally:
+            if exists(raw_tex_fn):
+                unlink(raw_tex_fn)
+
+        # 5. write texture info
+        self.write_tex(data, 'etc1_rgb8', (w, h), (w2, h2),
+                        self.options.mipmap)
+
+
+class PvrtcTool(Tool):
+    def __init__(self, options):
+        super(PvrtcTool, self).__init__(options)
+        self.texturetool = None
+        self.locate_texturetool()
+
+    def locate_texturetool(self):
+        search_directories = [
+            ('/Applications/Xcode.app/Contents/Developer/Platforms/'
+             'iPhoneOS.platform/Developer/usr/bin/'),
+            '/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/']
+        search_directories += environ.get('PATH', '').split(':')
+
+        for directory in search_directories:
+            fn = join(directory, 'texturetool')
+            if not exists(fn):
+                continue
+            print('Found texturetool at {}'.format(directory))
+            self.texturetool = fn
+            return
+
+        print('Error: Unable to locate "texturetool".\n'
+              'Please install the iPhone SDK, or the PowerVR SDK.\n'
+              'Then make sure that "texturetool" is available in your PATH.')
+        exit(1)
+
+    def compress(self):
+        # 1. open the source image, and get the dimensions
+        image = Image.open(self.source_fn)
+        w, h = image.size
+        print('Image size is {}x{}'.format(*image.size))
+
+        # 2. search the nearest 2^
+        w2 = self.nearest_pow2(w)
+        h2 = self.nearest_pow2(h)
+        print('Nearest power-of-2 size is {}x{}'.format(w2, h2))
+
+        # 3. for PVR, the image MUST be a square. use the bigger size then
+        s2 = max(w2, h2)
+        print('PVR need a square image, the texture will be {0}x{0}'
+                .format(s2))
+
+        ext = self.source_fn.rsplit('.', 1)[-1]
+        tmpfile = '/tmp/ktexturecompress.{}'.format(ext)
+        image = image.resize((s2, s2))
+        image.save(tmpfile)
+
+        # 4. invoke texture tool
+        raw_tex_fn = self.tex_fn + '.raw'
+        cmd = [self.texturetool]
+        if self.options.mipmap:
+            cmd += ['-m']
+        cmd += ['-e', 'PVRTC', '-o', raw_tex_fn, '-f', 'RAW', tmpfile]
+        try:
+            self.runcmd(cmd)
+            with open(raw_tex_fn, 'rb') as fd:
+                data = fd.read()
+        finally:
+            if exists(raw_tex_fn):
+                unlink(raw_tex_fn)
+
+        # 5. write texture info
+        self.write_tex(data, 'pvrtc_rgba4', (w, h), (s2, s2),
+                       self.options.mipmap)
+
+
+if __name__ == '__main__':
+    Tool.run()
diff --git a/kivy/tools/theming/defaulttheme/action_bar.png b/kivy/tools/theming/defaulttheme/action_bar.png
new file mode 100644
index 0000000..6ffa1ca
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/action_bar.png differ
diff --git a/kivy/tools/theming/defaulttheme/action_group.png b/kivy/tools/theming/defaulttheme/action_group.png
new file mode 100644
index 0000000..72a089c
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/action_group.png differ
diff --git a/kivy/tools/theming/defaulttheme/action_group_disabled.png b/kivy/tools/theming/defaulttheme/action_group_disabled.png
new file mode 100644
index 0000000..dc46168
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/action_group_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/action_group_down.png b/kivy/tools/theming/defaulttheme/action_group_down.png
new file mode 100644
index 0000000..b7de69f
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/action_group_down.png differ
diff --git a/kivy/tools/theming/defaulttheme/action_item.png b/kivy/tools/theming/defaulttheme/action_item.png
new file mode 100644
index 0000000..244f4fd
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/action_item.png differ
diff --git a/kivy/tools/theming/defaulttheme/action_item_down.png b/kivy/tools/theming/defaulttheme/action_item_down.png
new file mode 100644
index 0000000..b1f1f18
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/action_item_down.png differ
diff --git a/kivy/tools/theming/defaulttheme/action_view.png b/kivy/tools/theming/defaulttheme/action_view.png
new file mode 100644
index 0000000..244f4fd
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/action_view.png differ
diff --git a/kivy/tools/theming/defaulttheme/audio-volume-high.png b/kivy/tools/theming/defaulttheme/audio-volume-high.png
new file mode 100755
index 0000000..6391322
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/audio-volume-high.png differ
diff --git a/kivy/tools/theming/defaulttheme/audio-volume-low.png b/kivy/tools/theming/defaulttheme/audio-volume-low.png
new file mode 100755
index 0000000..a2eab79
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/audio-volume-low.png differ
diff --git a/kivy/tools/theming/defaulttheme/audio-volume-medium.png b/kivy/tools/theming/defaulttheme/audio-volume-medium.png
new file mode 100755
index 0000000..46a7652
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/audio-volume-medium.png differ
diff --git a/kivy/tools/theming/defaulttheme/audio-volume-muted.png b/kivy/tools/theming/defaulttheme/audio-volume-muted.png
new file mode 100755
index 0000000..042ff04
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/audio-volume-muted.png differ
diff --git a/kivy/tools/theming/defaulttheme/bubble.png b/kivy/tools/theming/defaulttheme/bubble.png
new file mode 100644
index 0000000..07c622e
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/bubble.png differ
diff --git a/kivy/tools/theming/defaulttheme/bubble_arrow.png b/kivy/tools/theming/defaulttheme/bubble_arrow.png
new file mode 100644
index 0000000..5333994
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/bubble_arrow.png differ
diff --git a/kivy/tools/theming/defaulttheme/bubble_btn.png b/kivy/tools/theming/defaulttheme/bubble_btn.png
new file mode 100644
index 0000000..a2908b0
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/bubble_btn.png differ
diff --git a/kivy/tools/theming/defaulttheme/bubble_btn_pressed.png b/kivy/tools/theming/defaulttheme/bubble_btn_pressed.png
new file mode 100644
index 0000000..78eb427
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/bubble_btn_pressed.png differ
diff --git a/kivy/tools/theming/defaulttheme/button.png b/kivy/tools/theming/defaulttheme/button.png
new file mode 100644
index 0000000..06b5ddd
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/button.png differ
diff --git a/kivy/tools/theming/defaulttheme/button_disabled.png b/kivy/tools/theming/defaulttheme/button_disabled.png
new file mode 100644
index 0000000..b0f13f8
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/button_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/button_disabled_pressed.png b/kivy/tools/theming/defaulttheme/button_disabled_pressed.png
new file mode 100644
index 0000000..faab85e
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/button_disabled_pressed.png differ
diff --git a/kivy/tools/theming/defaulttheme/button_pressed.png b/kivy/tools/theming/defaulttheme/button_pressed.png
new file mode 100644
index 0000000..6d08247
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/button_pressed.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_disabled_off.png b/kivy/tools/theming/defaulttheme/checkbox_disabled_off.png
new file mode 100644
index 0000000..ab9480f
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_disabled_off.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_disabled_on.png b/kivy/tools/theming/defaulttheme/checkbox_disabled_on.png
new file mode 100644
index 0000000..85be2de
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_disabled_on.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_off.png b/kivy/tools/theming/defaulttheme/checkbox_off.png
new file mode 100644
index 0000000..0b10f31
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_off.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_on.png b/kivy/tools/theming/defaulttheme/checkbox_on.png
new file mode 100644
index 0000000..b7f6c9a
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_on.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_radio_disabled_off.png b/kivy/tools/theming/defaulttheme/checkbox_radio_disabled_off.png
new file mode 100644
index 0000000..bfd74ce
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_radio_disabled_off.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_radio_disabled_on.png b/kivy/tools/theming/defaulttheme/checkbox_radio_disabled_on.png
new file mode 100644
index 0000000..344bf7a
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_radio_disabled_on.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_radio_off.png b/kivy/tools/theming/defaulttheme/checkbox_radio_off.png
new file mode 100644
index 0000000..b6a6ce4
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_radio_off.png differ
diff --git a/kivy/tools/theming/defaulttheme/checkbox_radio_on.png b/kivy/tools/theming/defaulttheme/checkbox_radio_on.png
new file mode 100644
index 0000000..76ccb64
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/checkbox_radio_on.png differ
diff --git a/kivy/tools/theming/defaulttheme/close.png b/kivy/tools/theming/defaulttheme/close.png
new file mode 100644
index 0000000..0d363ce
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/close.png differ
diff --git a/kivy/tools/theming/defaulttheme/filechooser_file.png b/kivy/tools/theming/defaulttheme/filechooser_file.png
new file mode 100644
index 0000000..48638d4
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/filechooser_file.png differ
diff --git a/kivy/tools/theming/defaulttheme/filechooser_folder.png b/kivy/tools/theming/defaulttheme/filechooser_folder.png
new file mode 100644
index 0000000..b1af013
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/filechooser_folder.png differ
diff --git a/kivy/tools/theming/defaulttheme/filechooser_selected.png b/kivy/tools/theming/defaulttheme/filechooser_selected.png
new file mode 100644
index 0000000..a2c9f3c
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/filechooser_selected.png differ
diff --git a/kivy/tools/theming/defaulttheme/image-missing.png b/kivy/tools/theming/defaulttheme/image-missing.png
new file mode 100644
index 0000000..831d554
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/image-missing.png differ
diff --git a/kivy/tools/theming/defaulttheme/media-playback-pause.png b/kivy/tools/theming/defaulttheme/media-playback-pause.png
new file mode 100755
index 0000000..9820a85
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/media-playback-pause.png differ
diff --git a/kivy/tools/theming/defaulttheme/media-playback-start.png b/kivy/tools/theming/defaulttheme/media-playback-start.png
new file mode 100755
index 0000000..dc375c0
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/media-playback-start.png differ
diff --git a/kivy/tools/theming/defaulttheme/media-playback-stop.png b/kivy/tools/theming/defaulttheme/media-playback-stop.png
new file mode 100755
index 0000000..dad2b6c
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/media-playback-stop.png differ
diff --git a/kivy/tools/theming/defaulttheme/modalview-background.png b/kivy/tools/theming/defaulttheme/modalview-background.png
new file mode 100644
index 0000000..a42c464
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/modalview-background.png differ
diff --git a/kivy/tools/theming/defaulttheme/overflow.png b/kivy/tools/theming/defaulttheme/overflow.png
new file mode 100755
index 0000000..c7ff417
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/overflow.png differ
diff --git a/kivy/tools/theming/defaulttheme/player-background.png b/kivy/tools/theming/defaulttheme/player-background.png
new file mode 100644
index 0000000..d2ddfe1
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/player-background.png differ
diff --git a/kivy/tools/theming/defaulttheme/player-play-overlay.png b/kivy/tools/theming/defaulttheme/player-play-overlay.png
new file mode 100644
index 0000000..6eba4bd
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/player-play-overlay.png differ
diff --git a/kivy/tools/theming/defaulttheme/previous_normal.png b/kivy/tools/theming/defaulttheme/previous_normal.png
new file mode 100644
index 0000000..9142d18
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/previous_normal.png differ
diff --git a/kivy/tools/theming/defaulttheme/progressbar.png b/kivy/tools/theming/defaulttheme/progressbar.png
new file mode 100644
index 0000000..32cbaf6
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/progressbar.png differ
diff --git a/kivy/tools/theming/defaulttheme/progressbar_background.png b/kivy/tools/theming/defaulttheme/progressbar_background.png
new file mode 100644
index 0000000..3cefae3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/progressbar_background.png differ
diff --git a/kivy/tools/theming/defaulttheme/ring.png b/kivy/tools/theming/defaulttheme/ring.png
new file mode 100644
index 0000000..10922e9
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/ring.png differ
diff --git a/kivy/tools/theming/defaulttheme/selector_left.png b/kivy/tools/theming/defaulttheme/selector_left.png
new file mode 100644
index 0000000..c2333fa
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/selector_left.png differ
diff --git a/kivy/tools/theming/defaulttheme/selector_middle.png b/kivy/tools/theming/defaulttheme/selector_middle.png
new file mode 100644
index 0000000..01c830e
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/selector_middle.png differ
diff --git a/kivy/tools/theming/defaulttheme/selector_right.png b/kivy/tools/theming/defaulttheme/selector_right.png
new file mode 100644
index 0000000..50479d4
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/selector_right.png differ
diff --git a/kivy/tools/theming/defaulttheme/separator.png b/kivy/tools/theming/defaulttheme/separator.png
new file mode 100755
index 0000000..45c6181
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/separator.png differ
diff --git a/kivy/tools/theming/defaulttheme/slider_cursor.png b/kivy/tools/theming/defaulttheme/slider_cursor.png
new file mode 100644
index 0000000..1de2ef3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/slider_cursor.png differ
diff --git a/kivy/tools/theming/defaulttheme/slider_cursor_disabled.png b/kivy/tools/theming/defaulttheme/slider_cursor_disabled.png
new file mode 100644
index 0000000..4212fca
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/slider_cursor_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/sliderh_background.png b/kivy/tools/theming/defaulttheme/sliderh_background.png
new file mode 100644
index 0000000..ceb3702
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/sliderh_background.png differ
diff --git a/kivy/tools/theming/defaulttheme/sliderh_background_disabled.png b/kivy/tools/theming/defaulttheme/sliderh_background_disabled.png
new file mode 100644
index 0000000..5cec7e7
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/sliderh_background_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/sliderv_background.png b/kivy/tools/theming/defaulttheme/sliderv_background.png
new file mode 100644
index 0000000..5a96951
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/sliderv_background.png differ
diff --git a/kivy/tools/theming/defaulttheme/sliderv_background_disabled.png b/kivy/tools/theming/defaulttheme/sliderv_background_disabled.png
new file mode 100644
index 0000000..35a72a3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/sliderv_background_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/spinner.png b/kivy/tools/theming/defaulttheme/spinner.png
new file mode 100644
index 0000000..3cb2d8b
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/spinner.png differ
diff --git a/kivy/tools/theming/defaulttheme/spinner_disabled.png b/kivy/tools/theming/defaulttheme/spinner_disabled.png
new file mode 100644
index 0000000..a6ed93b
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/spinner_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/spinner_pressed.png b/kivy/tools/theming/defaulttheme/spinner_pressed.png
new file mode 100644
index 0000000..77a29e0
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/spinner_pressed.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter.png b/kivy/tools/theming/defaulttheme/splitter.png
new file mode 100644
index 0000000..6b7b658
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_disabled.png b/kivy/tools/theming/defaulttheme/splitter_disabled.png
new file mode 100644
index 0000000..e1bb788
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_disabled_down.png b/kivy/tools/theming/defaulttheme/splitter_disabled_down.png
new file mode 100644
index 0000000..829c18d
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_disabled_down.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_disabled_down_h.png b/kivy/tools/theming/defaulttheme/splitter_disabled_down_h.png
new file mode 100644
index 0000000..ef78fc0
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_disabled_down_h.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_disabled_h.png b/kivy/tools/theming/defaulttheme/splitter_disabled_h.png
new file mode 100644
index 0000000..c175be2
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_disabled_h.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_down.png b/kivy/tools/theming/defaulttheme/splitter_down.png
new file mode 100644
index 0000000..ec15b4f
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_down.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_down_h.png b/kivy/tools/theming/defaulttheme/splitter_down_h.png
new file mode 100644
index 0000000..e59b427
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_down_h.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_grip.png b/kivy/tools/theming/defaulttheme/splitter_grip.png
new file mode 100644
index 0000000..c85bf4a
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_grip.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_grip_h.png b/kivy/tools/theming/defaulttheme/splitter_grip_h.png
new file mode 100644
index 0000000..480dc7d
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_grip_h.png differ
diff --git a/kivy/tools/theming/defaulttheme/splitter_h.png b/kivy/tools/theming/defaulttheme/splitter_h.png
new file mode 100644
index 0000000..d520d92
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/splitter_h.png differ
diff --git a/kivy/tools/theming/defaulttheme/switch-background.png b/kivy/tools/theming/defaulttheme/switch-background.png
new file mode 100644
index 0000000..987c5b4
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/switch-background.png differ
diff --git a/kivy/tools/theming/defaulttheme/switch-background_disabled.png b/kivy/tools/theming/defaulttheme/switch-background_disabled.png
new file mode 100644
index 0000000..130463f
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/switch-background_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/switch-button.png b/kivy/tools/theming/defaulttheme/switch-button.png
new file mode 100644
index 0000000..8421ee3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/switch-button.png differ
diff --git a/kivy/tools/theming/defaulttheme/switch-button_disabled.png b/kivy/tools/theming/defaulttheme/switch-button_disabled.png
new file mode 100644
index 0000000..c7370e8
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/switch-button_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/tab.png b/kivy/tools/theming/defaulttheme/tab.png
new file mode 100644
index 0000000..76a3fd3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tab.png differ
diff --git a/kivy/tools/theming/defaulttheme/tab_btn.png b/kivy/tools/theming/defaulttheme/tab_btn.png
new file mode 100644
index 0000000..c6297a0
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tab_btn.png differ
diff --git a/kivy/tools/theming/defaulttheme/tab_btn_disabled.png b/kivy/tools/theming/defaulttheme/tab_btn_disabled.png
new file mode 100644
index 0000000..727295a
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tab_btn_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/tab_btn_disabled_pressed.png b/kivy/tools/theming/defaulttheme/tab_btn_disabled_pressed.png
new file mode 100644
index 0000000..9f45ad3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tab_btn_disabled_pressed.png differ
diff --git a/kivy/tools/theming/defaulttheme/tab_btn_pressed.png b/kivy/tools/theming/defaulttheme/tab_btn_pressed.png
new file mode 100644
index 0000000..8175cd3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tab_btn_pressed.png differ
diff --git a/kivy/tools/theming/defaulttheme/tab_disabled.png b/kivy/tools/theming/defaulttheme/tab_disabled.png
new file mode 100644
index 0000000..b4c6645
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tab_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/textinput.png b/kivy/tools/theming/defaulttheme/textinput.png
new file mode 100644
index 0000000..7c80209
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/textinput.png differ
diff --git a/kivy/tools/theming/defaulttheme/textinput_active.png b/kivy/tools/theming/defaulttheme/textinput_active.png
new file mode 100644
index 0000000..406b0db
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/textinput_active.png differ
diff --git a/kivy/tools/theming/defaulttheme/textinput_disabled.png b/kivy/tools/theming/defaulttheme/textinput_disabled.png
new file mode 100644
index 0000000..e8c4587
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/textinput_disabled.png differ
diff --git a/kivy/tools/theming/defaulttheme/textinput_disabled_active.png b/kivy/tools/theming/defaulttheme/textinput_disabled_active.png
new file mode 100644
index 0000000..600c912
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/textinput_disabled_active.png differ
diff --git a/kivy/tools/theming/defaulttheme/tree_closed.png b/kivy/tools/theming/defaulttheme/tree_closed.png
new file mode 100644
index 0000000..d6ec34e
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tree_closed.png differ
diff --git a/kivy/tools/theming/defaulttheme/tree_opened.png b/kivy/tools/theming/defaulttheme/tree_opened.png
new file mode 100644
index 0000000..500c111
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/tree_opened.png differ
diff --git a/kivy/tools/theming/defaulttheme/vkeyboard_background.png b/kivy/tools/theming/defaulttheme/vkeyboard_background.png
new file mode 100644
index 0000000..44a5d2a
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/vkeyboard_background.png differ
diff --git a/kivy/tools/theming/defaulttheme/vkeyboard_disabled_background.png b/kivy/tools/theming/defaulttheme/vkeyboard_disabled_background.png
new file mode 100644
index 0000000..40ea4a3
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/vkeyboard_disabled_background.png differ
diff --git a/kivy/tools/theming/defaulttheme/vkeyboard_disabled_key_down.png b/kivy/tools/theming/defaulttheme/vkeyboard_disabled_key_down.png
new file mode 100644
index 0000000..21f5f84
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/vkeyboard_disabled_key_down.png differ
diff --git a/kivy/tools/theming/defaulttheme/vkeyboard_disabled_key_normal.png b/kivy/tools/theming/defaulttheme/vkeyboard_disabled_key_normal.png
new file mode 100644
index 0000000..d91c896
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/vkeyboard_disabled_key_normal.png differ
diff --git a/kivy/tools/theming/defaulttheme/vkeyboard_key_down.png b/kivy/tools/theming/defaulttheme/vkeyboard_key_down.png
new file mode 100644
index 0000000..49d22a2
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/vkeyboard_key_down.png differ
diff --git a/kivy/tools/theming/defaulttheme/vkeyboard_key_normal.png b/kivy/tools/theming/defaulttheme/vkeyboard_key_normal.png
new file mode 100644
index 0000000..f4e373d
Binary files /dev/null and b/kivy/tools/theming/defaulttheme/vkeyboard_key_normal.png differ
diff --git a/kivy/uix/__init__.py b/kivy/uix/__init__.py
new file mode 100644
index 0000000..2f1e6ad
--- /dev/null
+++ b/kivy/uix/__init__.py
@@ -0,0 +1,56 @@
+'''
+Widgets
+=======
+
+Widgets are elements of a graphical user interface that form part of the
+`User Experience <http://en.wikipedia.org/wiki/User_experience>`_.
+The `kivy.uix` module contains classes for creating and managing Widgets.
+Please refer to the :doc:`api-kivy.uix.widget` documentation for further
+information.
+
+Kivy widgets can be categorized as follows:
+
+- **UX widgets**: Classical user interface widgets, ready to be assembled to
+  create more complex widgets.
+
+    :doc:`api-kivy.uix.label`, :doc:`api-kivy.uix.button`,
+    :doc:`api-kivy.uix.checkbox`,
+    :doc:`api-kivy.uix.image`, :doc:`api-kivy.uix.slider`,
+    :doc:`api-kivy.uix.progressbar`, :doc:`api-kivy.uix.textinput`,
+    :doc:`api-kivy.uix.togglebutton`, :doc:`api-kivy.uix.switch`,
+    :doc:`api-kivy.uix.video`
+
+- **Layouts**: A layout widget does no rendering but just acts as a trigger
+  that arranges its children in a specific way. Read more on
+  :doc:`Layouts here <api-kivy.uix.layout>`.
+
+    :doc:`api-kivy.uix.anchorlayout`, :doc:`api-kivy.uix.boxlayout`,
+    :doc:`api-kivy.uix.floatlayout`,
+    :doc:`api-kivy.uix.gridlayout`, :doc:`api-kivy.uix.pagelayout`,
+    :doc:`api-kivy.uix.relativelayout`, :doc:`api-kivy.uix.scatterlayout`,
+    :doc:`api-kivy.uix.stacklayout`
+
+- **Complex UX widgets**: Non-atomic widgets that are the result of
+  combining multiple classic widgets.
+  We call them complex because their assembly and usage are not as
+  generic as the classical widgets.
+
+    :doc:`api-kivy.uix.bubble`, :doc:`api-kivy.uix.dropdown`,
+    :doc:`api-kivy.uix.filechooser`, :doc:`api-kivy.uix.popup`,
+    :doc:`api-kivy.uix.spinner`,
+    :doc:`api-kivy.uix.recycleview`,
+    :doc:`api-kivy.uix.tabbedpanel`, :doc:`api-kivy.uix.videoplayer`,
+    :doc:`api-kivy.uix.vkeyboard`,
+
+- **Behaviors widgets**: These widgets do no rendering but act on the
+  graphics instructions or interaction (touch) behavior of their children.
+
+    :doc:`api-kivy.uix.scatter`, :doc:`api-kivy.uix.stencilview`
+
+- **Screen manager**: Manages screens and transitions when switching
+  from one to another.
+
+    :doc:`api-kivy.uix.screenmanager`
+
+----
+'''
diff --git a/kivy/uix/__pycache__/__init__.cpython-310.pyc b/kivy/uix/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..a460c7c
Binary files /dev/null and b/kivy/uix/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/accordion.cpython-310.pyc b/kivy/uix/__pycache__/accordion.cpython-310.pyc
new file mode 100644
index 0000000..91e4532
Binary files /dev/null and b/kivy/uix/__pycache__/accordion.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/actionbar.cpython-310.pyc b/kivy/uix/__pycache__/actionbar.cpython-310.pyc
new file mode 100644
index 0000000..dc4952f
Binary files /dev/null and b/kivy/uix/__pycache__/actionbar.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/anchorlayout.cpython-310.pyc b/kivy/uix/__pycache__/anchorlayout.cpython-310.pyc
new file mode 100644
index 0000000..f9763d9
Binary files /dev/null and b/kivy/uix/__pycache__/anchorlayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/boxlayout.cpython-310.pyc b/kivy/uix/__pycache__/boxlayout.cpython-310.pyc
new file mode 100644
index 0000000..6028375
Binary files /dev/null and b/kivy/uix/__pycache__/boxlayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/bubble.cpython-310.pyc b/kivy/uix/__pycache__/bubble.cpython-310.pyc
new file mode 100644
index 0000000..d5bdc41
Binary files /dev/null and b/kivy/uix/__pycache__/bubble.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/button.cpython-310.pyc b/kivy/uix/__pycache__/button.cpython-310.pyc
new file mode 100644
index 0000000..7108c6f
Binary files /dev/null and b/kivy/uix/__pycache__/button.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/camera.cpython-310.pyc b/kivy/uix/__pycache__/camera.cpython-310.pyc
new file mode 100644
index 0000000..4d3dfe3
Binary files /dev/null and b/kivy/uix/__pycache__/camera.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/carousel.cpython-310.pyc b/kivy/uix/__pycache__/carousel.cpython-310.pyc
new file mode 100644
index 0000000..7026f6d
Binary files /dev/null and b/kivy/uix/__pycache__/carousel.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/checkbox.cpython-310.pyc b/kivy/uix/__pycache__/checkbox.cpython-310.pyc
new file mode 100644
index 0000000..5c7da48
Binary files /dev/null and b/kivy/uix/__pycache__/checkbox.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/codeinput.cpython-310.pyc b/kivy/uix/__pycache__/codeinput.cpython-310.pyc
new file mode 100644
index 0000000..b931e21
Binary files /dev/null and b/kivy/uix/__pycache__/codeinput.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/colorpicker.cpython-310.pyc b/kivy/uix/__pycache__/colorpicker.cpython-310.pyc
new file mode 100644
index 0000000..fbe8fac
Binary files /dev/null and b/kivy/uix/__pycache__/colorpicker.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/dropdown.cpython-310.pyc b/kivy/uix/__pycache__/dropdown.cpython-310.pyc
new file mode 100644
index 0000000..db3bfac
Binary files /dev/null and b/kivy/uix/__pycache__/dropdown.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/effectwidget.cpython-310.pyc b/kivy/uix/__pycache__/effectwidget.cpython-310.pyc
new file mode 100644
index 0000000..fa7c6b1
Binary files /dev/null and b/kivy/uix/__pycache__/effectwidget.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/filechooser.cpython-310.pyc b/kivy/uix/__pycache__/filechooser.cpython-310.pyc
new file mode 100644
index 0000000..3bf04ea
Binary files /dev/null and b/kivy/uix/__pycache__/filechooser.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/floatlayout.cpython-310.pyc b/kivy/uix/__pycache__/floatlayout.cpython-310.pyc
new file mode 100644
index 0000000..f753c29
Binary files /dev/null and b/kivy/uix/__pycache__/floatlayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/gesturesurface.cpython-310.pyc b/kivy/uix/__pycache__/gesturesurface.cpython-310.pyc
new file mode 100644
index 0000000..df8e5d9
Binary files /dev/null and b/kivy/uix/__pycache__/gesturesurface.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/gridlayout.cpython-310.pyc b/kivy/uix/__pycache__/gridlayout.cpython-310.pyc
new file mode 100644
index 0000000..e6abdf2
Binary files /dev/null and b/kivy/uix/__pycache__/gridlayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/image.cpython-310.pyc b/kivy/uix/__pycache__/image.cpython-310.pyc
new file mode 100644
index 0000000..9e5b177
Binary files /dev/null and b/kivy/uix/__pycache__/image.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/label.cpython-310.pyc b/kivy/uix/__pycache__/label.cpython-310.pyc
new file mode 100644
index 0000000..a2c25b8
Binary files /dev/null and b/kivy/uix/__pycache__/label.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/layout.cpython-310.pyc b/kivy/uix/__pycache__/layout.cpython-310.pyc
new file mode 100644
index 0000000..266dba9
Binary files /dev/null and b/kivy/uix/__pycache__/layout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/modalview.cpython-310.pyc b/kivy/uix/__pycache__/modalview.cpython-310.pyc
new file mode 100644
index 0000000..2cf8ed2
Binary files /dev/null and b/kivy/uix/__pycache__/modalview.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/pagelayout.cpython-310.pyc b/kivy/uix/__pycache__/pagelayout.cpython-310.pyc
new file mode 100644
index 0000000..de5f9d4
Binary files /dev/null and b/kivy/uix/__pycache__/pagelayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/popup.cpython-310.pyc b/kivy/uix/__pycache__/popup.cpython-310.pyc
new file mode 100644
index 0000000..36c6de8
Binary files /dev/null and b/kivy/uix/__pycache__/popup.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/progressbar.cpython-310.pyc b/kivy/uix/__pycache__/progressbar.cpython-310.pyc
new file mode 100644
index 0000000..8df4331
Binary files /dev/null and b/kivy/uix/__pycache__/progressbar.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/recycleboxlayout.cpython-310.pyc b/kivy/uix/__pycache__/recycleboxlayout.cpython-310.pyc
new file mode 100644
index 0000000..9b40a90
Binary files /dev/null and b/kivy/uix/__pycache__/recycleboxlayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/recyclegridlayout.cpython-310.pyc b/kivy/uix/__pycache__/recyclegridlayout.cpython-310.pyc
new file mode 100644
index 0000000..78a3963
Binary files /dev/null and b/kivy/uix/__pycache__/recyclegridlayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/recyclelayout.cpython-310.pyc b/kivy/uix/__pycache__/recyclelayout.cpython-310.pyc
new file mode 100644
index 0000000..a26da1e
Binary files /dev/null and b/kivy/uix/__pycache__/recyclelayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/relativelayout.cpython-310.pyc b/kivy/uix/__pycache__/relativelayout.cpython-310.pyc
new file mode 100644
index 0000000..bd021c4
Binary files /dev/null and b/kivy/uix/__pycache__/relativelayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/rst.cpython-310.pyc b/kivy/uix/__pycache__/rst.cpython-310.pyc
new file mode 100644
index 0000000..0c32617
Binary files /dev/null and b/kivy/uix/__pycache__/rst.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/sandbox.cpython-310.pyc b/kivy/uix/__pycache__/sandbox.cpython-310.pyc
new file mode 100644
index 0000000..23deef1
Binary files /dev/null and b/kivy/uix/__pycache__/sandbox.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/scatter.cpython-310.pyc b/kivy/uix/__pycache__/scatter.cpython-310.pyc
new file mode 100644
index 0000000..1e6388f
Binary files /dev/null and b/kivy/uix/__pycache__/scatter.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/scatterlayout.cpython-310.pyc b/kivy/uix/__pycache__/scatterlayout.cpython-310.pyc
new file mode 100644
index 0000000..baa8f21
Binary files /dev/null and b/kivy/uix/__pycache__/scatterlayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/screenmanager.cpython-310.pyc b/kivy/uix/__pycache__/screenmanager.cpython-310.pyc
new file mode 100644
index 0000000..be61f51
Binary files /dev/null and b/kivy/uix/__pycache__/screenmanager.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/scrollview.cpython-310.pyc b/kivy/uix/__pycache__/scrollview.cpython-310.pyc
new file mode 100644
index 0000000..2fce4a9
Binary files /dev/null and b/kivy/uix/__pycache__/scrollview.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/settings.cpython-310.pyc b/kivy/uix/__pycache__/settings.cpython-310.pyc
new file mode 100644
index 0000000..fddd2b5
Binary files /dev/null and b/kivy/uix/__pycache__/settings.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/slider.cpython-310.pyc b/kivy/uix/__pycache__/slider.cpython-310.pyc
new file mode 100644
index 0000000..6c2ac55
Binary files /dev/null and b/kivy/uix/__pycache__/slider.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/spinner.cpython-310.pyc b/kivy/uix/__pycache__/spinner.cpython-310.pyc
new file mode 100644
index 0000000..eca18da
Binary files /dev/null and b/kivy/uix/__pycache__/spinner.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/splitter.cpython-310.pyc b/kivy/uix/__pycache__/splitter.cpython-310.pyc
new file mode 100644
index 0000000..04e1d95
Binary files /dev/null and b/kivy/uix/__pycache__/splitter.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/stacklayout.cpython-310.pyc b/kivy/uix/__pycache__/stacklayout.cpython-310.pyc
new file mode 100644
index 0000000..2ca2a29
Binary files /dev/null and b/kivy/uix/__pycache__/stacklayout.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/stencilview.cpython-310.pyc b/kivy/uix/__pycache__/stencilview.cpython-310.pyc
new file mode 100644
index 0000000..68c335d
Binary files /dev/null and b/kivy/uix/__pycache__/stencilview.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/switch.cpython-310.pyc b/kivy/uix/__pycache__/switch.cpython-310.pyc
new file mode 100644
index 0000000..8c1f94e
Binary files /dev/null and b/kivy/uix/__pycache__/switch.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/tabbedpanel.cpython-310.pyc b/kivy/uix/__pycache__/tabbedpanel.cpython-310.pyc
new file mode 100644
index 0000000..379214e
Binary files /dev/null and b/kivy/uix/__pycache__/tabbedpanel.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/textinput.cpython-310.pyc b/kivy/uix/__pycache__/textinput.cpython-310.pyc
new file mode 100644
index 0000000..4295cc7
Binary files /dev/null and b/kivy/uix/__pycache__/textinput.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/togglebutton.cpython-310.pyc b/kivy/uix/__pycache__/togglebutton.cpython-310.pyc
new file mode 100644
index 0000000..5854f70
Binary files /dev/null and b/kivy/uix/__pycache__/togglebutton.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/treeview.cpython-310.pyc b/kivy/uix/__pycache__/treeview.cpython-310.pyc
new file mode 100644
index 0000000..be469b3
Binary files /dev/null and b/kivy/uix/__pycache__/treeview.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/video.cpython-310.pyc b/kivy/uix/__pycache__/video.cpython-310.pyc
new file mode 100644
index 0000000..f96134a
Binary files /dev/null and b/kivy/uix/__pycache__/video.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/videoplayer.cpython-310.pyc b/kivy/uix/__pycache__/videoplayer.cpython-310.pyc
new file mode 100644
index 0000000..628ab7f
Binary files /dev/null and b/kivy/uix/__pycache__/videoplayer.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/vkeyboard.cpython-310.pyc b/kivy/uix/__pycache__/vkeyboard.cpython-310.pyc
new file mode 100644
index 0000000..da86127
Binary files /dev/null and b/kivy/uix/__pycache__/vkeyboard.cpython-310.pyc differ
diff --git a/kivy/uix/__pycache__/widget.cpython-310.pyc b/kivy/uix/__pycache__/widget.cpython-310.pyc
new file mode 100644
index 0000000..9e59885
Binary files /dev/null and b/kivy/uix/__pycache__/widget.cpython-310.pyc differ
diff --git a/kivy/uix/accordion.py b/kivy/uix/accordion.py
new file mode 100644
index 0000000..fa855f4
--- /dev/null
+++ b/kivy/uix/accordion.py
@@ -0,0 +1,484 @@
+'''
+Accordion
+=========
+
+.. versionadded:: 1.0.8
+
+
+.. image:: images/accordion.jpg
+    :align: right
+
+The Accordion widget is a form of menu where the options are stacked either
+vertically or horizontally and the item in focus (when touched) opens up to
+display its content.
+
+The :class:`Accordion` should contain one or many :class:`AccordionItem`
+instances, each of which should contain one root content widget. You'll end up
+with a Tree something like this:
+
+- Accordion
+
+  - AccordionItem
+
+    - YourContent
+
+  - AccordionItem
+
+    - BoxLayout
+
+      - Another user content 1
+
+      - Another user content 2
+
+  - AccordionItem
+
+    - Another user content
+
+
+The current implementation divides the :class:`AccordionItem` into two parts:
+
+#. One container for the title bar
+#. One container for the content
+
+The title bar is made from a Kv template. We'll see how to create a new
+template to customize the design of the title bar.
+
+.. warning::
+
+    If you see message like::
+
+        [WARNING] [Accordion] not have enough space for displaying all children
+        [WARNING] [Accordion] need 440px, got 100px
+        [WARNING] [Accordion] layout aborted.
+
+    That means you have too many children and there is no more space to
+    display the content. This is "normal" and nothing will be done. Try to
+    increase the space for the accordion or reduce the number of children. You
+    can also reduce the :attr:`Accordion.min_space`.
+
+Simple example
+--------------
+
+.. include:: ../../examples/widgets/accordion_1.py
+    :literal:
+
+Customize the accordion
+-----------------------
+
+You can increase the default size of the title bar::
+
+    root = Accordion(min_space=60)
+
+Or change the orientation to vertical::
+
+    root = Accordion(orientation='vertical')
+
+The AccordionItem is more configurable and you can set your own title
+background when the item is collapsed or opened::
+
+    item = AccordionItem(background_normal='image_when_collapsed.png',
+        background_selected='image_when_selected.png')
+
+'''
+
+__all__ = ('Accordion', 'AccordionItem', 'AccordionException')
+
+from kivy.animation import Animation
+from kivy.uix.floatlayout import FloatLayout
+from kivy.clock import Clock
+from kivy.lang import Builder
+from kivy.properties import (ObjectProperty, StringProperty,
+                             BooleanProperty, NumericProperty,
+                             ListProperty, OptionProperty, DictProperty)
+from kivy.uix.widget import Widget
+from kivy.logger import Logger
+
+
+class AccordionException(Exception):
+    '''AccordionException class.
+    '''
+    pass
+
+
+class AccordionItem(FloatLayout):
+    '''AccordionItem class that must be used in conjunction with the
+    :class:`Accordion` class. See the module documentation for more
+    information.
+    '''
+
+    title = StringProperty('')
+    '''Title string of the item. The title might be used in conjunction with the
+    `AccordionItemTitle` template. If you are using a custom template, you can
+    use that property as a text entry, or not. By default, it's used for the
+    title text. See title_template and the example below.
+
+    :attr:`title` is a :class:`~kivy.properties.StringProperty` and defaults
+    to ''.
+    '''
+
+    title_template = StringProperty('AccordionItemTitle')
+    '''Template to use for creating the title part of the accordion item. The
+    default template is a simple Label, not customizable (except the text) that
+    supports vertical and horizontal orientation and different backgrounds for
+    collapse and selected mode.
+
+    It's better to create and use your own template if the default template
+    does not suffice.
+
+    :attr:`title` is a :class:`~kivy.properties.StringProperty` and defaults to
+    'AccordionItemTitle'. The current default template lives in the
+    `kivy/data/style.kv` file.
+
+    Here is the code if you want to build your own template::
+
+        [AccordionItemTitle@Label]:
+            text: ctx.title
+            canvas.before:
+                Color:
+                    rgb: 1, 1, 1
+                BorderImage:
+                    source:
+                        ctx.item.background_normal \
+                        if ctx.item.collapse \
+                        else ctx.item.background_selected
+                    pos: self.pos
+                    size: self.size
+                PushMatrix
+                Translate:
+                    xy: self.center_x, self.center_y
+                Rotate:
+                    angle: 90 if ctx.item.orientation == 'horizontal' else 0
+                    axis: 0, 0, 1
+                Translate:
+                    xy: -self.center_x, -self.center_y
+            canvas.after:
+                PopMatrix
+
+
+    '''
+
+    title_args = DictProperty({})
+    '''Default arguments that will be passed to the
+    :meth:`kivy.lang.Builder.template` method.
+
+    :attr:`title_args` is a :class:`~kivy.properties.DictProperty` and defaults
+    to {}.
+    '''
+
+    collapse = BooleanProperty(True)
+    '''Boolean to indicate if the current item is collapsed or not.
+
+    :attr:`collapse` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    collapse_alpha = NumericProperty(1.)
+    '''Value between 0 and 1 to indicate how much the item is collapsed (1) or
+    whether it is selected (0). It's mostly used for animation.
+
+    :attr:`collapse_alpha` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+    '''
+
+    accordion = ObjectProperty(None)
+    '''Instance of the :class:`Accordion` that the item belongs to.
+
+    :attr:`accordion` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    background_normal = StringProperty(
+        'atlas://data/images/defaulttheme/button')
+    '''Background image of the accordion item used for the default graphical
+    representation when the item is collapsed.
+
+    :attr:`background_normal` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/button'.
+    '''
+
+    background_disabled_normal = StringProperty(
+        'atlas://data/images/defaulttheme/button_disabled')
+    '''Background image of the accordion item used for the default graphical
+    representation when the item is collapsed and disabled.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background__disabled_normal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/button_disabled'.
+    '''
+
+    background_selected = StringProperty(
+        'atlas://data/images/defaulttheme/button_pressed')
+    '''Background image of the accordion item used for the default graphical
+    representation when the item is selected (not collapsed).
+
+    :attr:`background_normal` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/button_pressed'.
+    '''
+
+    background_disabled_selected = StringProperty(
+        'atlas://data/images/defaulttheme/button_disabled_pressed')
+    '''Background image of the accordion item used for the default graphical
+    representation when the item is selected (not collapsed) and disabled.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background_disabled_selected` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/button_disabled_pressed'.
+    '''
+
+    orientation = OptionProperty('vertical', options=(
+        'horizontal', 'vertical'))
+    '''Link to the :attr:`Accordion.orientation` property.
+    '''
+
+    min_space = NumericProperty('44dp')
+    '''Link to the :attr:`Accordion.min_space` property.
+    '''
+
+    content_size = ListProperty([100, 100])
+    '''(internal) Set by the :class:`Accordion` to the size allocated for the
+    content.
+    '''
+
+    container = ObjectProperty(None)
+    '''(internal) Property that will be set to the container of children inside
+    the AccordionItem representation.
+    '''
+
+    container_title = ObjectProperty(None)
+    '''(internal) Property that will be set to the container of title inside
+    the AccordionItem representation.
+    '''
+
+    def __init__(self, **kwargs):
+        self._trigger_title = Clock.create_trigger(self._update_title, -1)
+        self._anim_collapse = None
+        super(AccordionItem, self).__init__(**kwargs)
+        trigger_title = self._trigger_title
+        fbind = self.fbind
+        fbind('title', trigger_title)
+        fbind('title_template', trigger_title)
+        fbind('title_args', trigger_title)
+        trigger_title()
+
+    def add_widget(self, *args, **kwargs):
+        if self.container is None:
+            super(AccordionItem, self).add_widget(*args, **kwargs)
+            return
+        self.container.add_widget(*args, **kwargs)
+
+    def remove_widget(self, *args, **kwargs):
+        if self.container:
+            self.container.remove_widget(*args, **kwargs)
+            return
+        super(AccordionItem, self).remove_widget(*args, **kwargs)
+
+    def on_collapse(self, instance, value):
+        accordion = self.accordion
+        if accordion is None:
+            return
+        if not value:
+            self.accordion.select(self)
+        collapse_alpha = float(value)
+        if self._anim_collapse:
+            self._anim_collapse.stop(self)
+            self._anim_collapse = None
+        if self.collapse_alpha != collapse_alpha:
+            self._anim_collapse = Animation(
+                collapse_alpha=collapse_alpha,
+                t=accordion.anim_func,
+                d=accordion.anim_duration)
+            self._anim_collapse.start(self)
+
+    def on_collapse_alpha(self, instance, value):
+        self.accordion._trigger_layout()
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return
+        if self.disabled:
+            return True
+        if self.collapse:
+            self.collapse = False
+            return True
+        else:
+            return super(AccordionItem, self).on_touch_down(touch)
+
+    def _update_title(self, dt):
+        if not self.container_title:
+            self._trigger_title()
+            return
+        c = self.container_title
+        c.clear_widgets()
+        instance = Builder.template(self.title_template,
+                                    title=self.title,
+                                    item=self,
+                                    **self.title_args)
+        c.add_widget(instance)
+
+
+class Accordion(Widget):
+    '''Accordion class. See module documentation for more information.
+    '''
+
+    orientation = OptionProperty('horizontal', options=(
+        'horizontal', 'vertical'))
+    '''Orientation of the layout.
+
+    :attr:`orientation` is an :class:`~kivy.properties.OptionProperty`
+    and defaults to 'horizontal'. Can take a value of 'vertical' or
+    'horizontal'.
+
+    '''
+
+    anim_duration = NumericProperty(.25)
+    '''Duration of the animation in seconds when a new accordion item is
+    selected.
+
+    :attr:`anim_duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to .25 (250ms).
+    '''
+
+    anim_func = ObjectProperty('out_expo')
+    '''Easing function to use for the animation. Check
+    :class:`kivy.animation.AnimationTransition` for more information about
+    available animation functions.
+
+    :attr:`anim_func` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to 'out_expo'. You can set a string or a function to use as an
+    easing function.
+    '''
+
+    min_space = NumericProperty('44dp')
+    '''Minimum space to use for the title of each item. This value is
+    automatically set for each child every time the layout event occurs.
+
+    :attr:`min_space` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 44 (px).
+    '''
+
+    def __init__(self, **kwargs):
+        super(Accordion, self).__init__(**kwargs)
+        update = self._trigger_layout = \
+            Clock.create_trigger(self._do_layout, -1)
+        fbind = self.fbind
+        fbind('orientation', update)
+        fbind('children', update)
+        fbind('size', update)
+        fbind('pos', update)
+        fbind('min_space', update)
+
+    def add_widget(self, widget, *args, **kwargs):
+        if not isinstance(widget, AccordionItem):
+            raise AccordionException('Accordion accept only AccordionItem')
+        widget.accordion = self
+        super(Accordion, self).add_widget(widget, *args, **kwargs)
+
+    def select(self, instance):
+        if instance not in self.children:
+            raise AccordionException(
+                'Accordion: instance not found in children')
+        for widget in self.children:
+            widget.collapse = widget is not instance
+        self._trigger_layout()
+
+    def _do_layout(self, dt):
+        children = self.children
+        if children:
+            all_collapsed = all(x.collapse for x in children)
+        else:
+            all_collapsed = False
+
+        if all_collapsed:
+            children[0].collapse = False
+
+        orientation = self.orientation
+        min_space = self.min_space
+        min_space_total = len(children) * self.min_space
+        w, h = self.size
+        x, y = self.pos
+        if orientation == 'horizontal':
+            display_space = self.width - min_space_total
+        else:
+            display_space = self.height - min_space_total
+
+        if display_space <= 0:
+            Logger.warning('Accordion: not enough space '
+                           'for displaying all children')
+            Logger.warning('Accordion: need %dpx, got %dpx' % (
+                min_space_total, min_space_total + display_space))
+            Logger.warning('Accordion: layout aborted.')
+            return
+
+        if orientation == 'horizontal':
+            children = reversed(children)
+
+        for child in children:
+            child_space = min_space
+            child_space += display_space * (1 - child.collapse_alpha)
+            child._min_space = min_space
+            child.x = x
+            child.y = y
+            child.orientation = self.orientation
+            if orientation == 'horizontal':
+                child.content_size = display_space, h
+                child.width = child_space
+                child.height = h
+                x += child_space
+            else:
+                child.content_size = w, display_space
+                child.width = w
+                child.height = child_space
+                y += child_space
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    from kivy.uix.button import Button
+    from kivy.uix.boxlayout import BoxLayout
+    from kivy.uix.label import Label
+
+    acc = Accordion()
+    for x in range(10):
+        item = AccordionItem(title='Title %d' % x)
+        if x == 0:
+            item.add_widget(Button(text='Content %d' % x))
+        elif x == 1:
+            z = BoxLayout(orientation='vertical')
+            z.add_widget(Button(text=str(x), size_hint_y=None, height=35))
+            z.add_widget(Label(text='Content %d' % x))
+            item.add_widget(z)
+        else:
+            item.add_widget(Label(text='This is a big content\n' * 20))
+        acc.add_widget(item)
+
+    def toggle_layout(*l):
+        o = acc.orientation
+        acc.orientation = 'vertical' if o == 'horizontal' else 'horizontal'
+    btn = Button(text='Toggle layout')
+    btn.bind(on_release=toggle_layout)
+
+    def select_2nd_item(*l):
+        acc.select(acc.children[-2])
+    btn2 = Button(text='Select 2nd item')
+    btn2.bind(on_release=select_2nd_item)
+
+    from kivy.uix.slider import Slider
+    slider = Slider()
+
+    def update_min_space(instance, value):
+        acc.min_space = value
+
+    slider.bind(value=update_min_space)
+
+    root = BoxLayout(spacing=20, padding=20)
+    controls = BoxLayout(orientation='vertical', size_hint_x=.3)
+    controls.add_widget(btn)
+    controls.add_widget(btn2)
+    controls.add_widget(slider)
+    root.add_widget(controls)
+    root.add_widget(acc)
+    runTouchApp(root)
diff --git a/kivy/uix/actionbar.py b/kivy/uix/actionbar.py
new file mode 100644
index 0000000..e329378
--- /dev/null
+++ b/kivy/uix/actionbar.py
@@ -0,0 +1,933 @@
+'''
+Action Bar
+==========
+
+.. versionadded:: 1.8.0
+
+.. image:: images/actionbar.png
+    :align: right
+
+The ActionBar widget is like Android's `ActionBar
+<http://developer.android.com/guide/topics/ui/actionbar.html>`_, where items
+are stacked horizontally. When the area becomes to small, widgets are moved
+into the :class:`ActionOverflow` area.
+
+An :class:`ActionBar` contains an :class:`ActionView` with various
+:class:`ContextualActionViews <kivy.uix.actionbar.ContextualActionView>`.
+An :class:`ActionView` will contain an :class:`ActionPrevious` having title,
+app_icon and previous_icon properties. An :class:`ActionView` will contain
+subclasses of :class:`ActionItems <ActionItem>`. Some predefined ones include
+an :class:`ActionButton`, an :class:`ActionToggleButton`, an
+:class:`ActionCheck`, an :class:`ActionSeparator` and an :class:`ActionGroup`.
+
+An :class:`ActionGroup` is used to display :class:`ActionItems <ActionItem>`
+in a group. An :class:`ActionView` will always display an :class:`ActionGroup`
+after other :class:`ActionItems <ActionItem>`. An :class:`ActionView` contains
+an :class:`ActionOverflow`, but this is only made visible when required i.e.
+the available area is too small to fit all the widgets. A
+:class:`ContextualActionView` is a subclass of an:class:`ActionView`.
+
+.. versionchanged:: 1.10.1
+    :class:`ActionGroup` core rewritten from :class:`Spinner` to pure
+    :class:`DropDown`
+'''
+
+__all__ = ('ActionBarException', 'ActionItem', 'ActionButton',
+           'ActionToggleButton', 'ActionCheck', 'ActionSeparator',
+           'ActionDropDown', 'ActionGroup', 'ActionOverflow',
+           'ActionView', 'ContextualActionView', 'ActionPrevious',
+           'ActionBar')
+
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.dropdown import DropDown
+from kivy.uix.widget import Widget
+from kivy.uix.button import Button
+from kivy.uix.togglebutton import ToggleButton
+from kivy.uix.checkbox import CheckBox
+from kivy.uix.spinner import Spinner
+from kivy.uix.label import Label
+from kivy.config import Config
+from kivy.properties import ObjectProperty, NumericProperty, BooleanProperty, \
+    StringProperty, ListProperty, OptionProperty, AliasProperty, ColorProperty
+from kivy.metrics import sp
+from kivy.lang import Builder
+from functools import partial
+
+
+window_icon = ''
+if Config:
+    window_icon = Config.get('kivy', 'window_icon')
+
+
+class ActionBarException(Exception):
+    '''
+    ActionBarException class
+    '''
+    pass
+
+
+class ActionItem(object):
+    '''
+    ActionItem class, an abstract class for all ActionBar widgets. To create a
+    custom widget for an ActionBar, inherit from this class. See module
+    documentation for more information.
+    '''
+
+    minimum_width = NumericProperty('90sp')
+    '''
+    Minimum Width required by an ActionItem.
+
+    :attr:`minimum_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to '90sp'.
+    '''
+
+    def get_pack_width(self):
+        return max(self.minimum_width, self.width)
+
+    pack_width = AliasProperty(get_pack_width,
+                               bind=('minimum_width', 'width'),
+                               cache=True)
+    '''
+    (read-only) The actual width to use when packing the items. Equal to the
+    greater of minimum_width and width.
+
+    :attr:`pack_width` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    important = BooleanProperty(False)
+    '''
+    Determines if an ActionItem is important or not. If an item is important
+    and space is limited, this item will be displayed in preference to others.
+
+    :attr:`important` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    inside_group = BooleanProperty(False)
+    '''
+    (internal) Determines if an ActionItem is displayed inside an
+    ActionGroup or not.
+
+    :attr:`inside_group` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    background_normal = StringProperty(
+        'atlas://data/images/defaulttheme/action_item')
+    '''
+    Background image of the ActionItem used for the default graphical
+    representation when the ActionItem is not pressed.
+
+    :attr:`background_normal` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/action_item'.
+    '''
+
+    background_down = StringProperty(
+        'atlas://data/images/defaulttheme/action_item_down')
+    '''
+    Background image of the ActionItem used for the default graphical
+    representation when an ActionItem is pressed.
+
+    :attr:`background_down` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/action_item_down'.
+    '''
+
+    mipmap = BooleanProperty(True)
+    '''
+    Defines whether the image/icon dispayed on top of the button uses a
+    mipmap or not.
+
+    :attr:`mipmap` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to `True`.
+    '''
+
+
+class ActionButton(Button, ActionItem):
+    '''
+    ActionButton class, see module documentation for more information.
+
+    The text color, width and size_hint_x are set manually via the Kv language
+    file. It covers a lot of cases: with/without an icon, with/without a group
+    and takes care of the padding between elements.
+
+    You don't have much control over these properties, so if you want to
+    customize its appearance, we suggest you create you own button
+    representation. You can do this by creating a class that subclasses an
+    existing widget and an :class:`ActionItem`::
+
+        class MyOwnActionButton(Button, ActionItem):
+            pass
+
+    You can then create your own style using the Kv language.
+    '''
+
+    icon = StringProperty(None, allownone=True)
+    '''
+    Source image to use when the Button is part of the ActionBar. If the
+    Button is in a group, the text will be preferred.
+
+    :attr:`icon` is a :class:`~kivy.properties.StringProperty` and defaults
+    to None.
+    '''
+
+
+class ActionPrevious(BoxLayout, ActionItem):
+    '''
+    ActionPrevious class, see module documentation for more information.
+    '''
+
+    with_previous = BooleanProperty(True)
+    '''
+    Specifies whether the previous_icon will be shown or not. Note that it is
+    up to the user to implement the desired behavior using the *on_press* or
+    similar events.
+
+    :attr:`with_previous` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    app_icon = StringProperty(window_icon)
+    '''
+    Application icon for the ActionView.
+
+    :attr:`app_icon` is a :class:`~kivy.properties.StringProperty`
+    and defaults to the window icon if set, otherwise
+    'data/logo/kivy-icon-32.png'.
+    '''
+
+    app_icon_width = NumericProperty(0)
+    '''
+    Width of app_icon image.
+
+    :attr:`app_icon_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    app_icon_height = NumericProperty(0)
+    '''
+    Height of app_icon image.
+
+    :attr:`app_icon_height` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    color = ColorProperty([1, 1, 1, 1])
+    '''
+    Text color, in the format (r, g, b, a)
+
+    :attr:`color` is a :class:`~kivy.properties.ColorProperty` and defaults
+    to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    previous_image = StringProperty(
+        'atlas://data/images/defaulttheme/previous_normal')
+    '''
+    Image for the 'previous' ActionButtons default graphical representation.
+
+    :attr:`previous_image` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/previous_normal'.
+    '''
+
+    previous_image_width = NumericProperty(0)
+    '''
+    Width of previous_image image.
+
+    :attr:`width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    previous_image_height = NumericProperty(0)
+    '''
+    Height of previous_image image.
+
+    :attr:`app_icon_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    title = StringProperty('')
+    '''
+    Title for ActionView.
+
+    :attr:`title` is a :class:`~kivy.properties.StringProperty` and
+    defaults to ''.
+    '''
+
+    markup = BooleanProperty(False)
+    '''
+    If True, the text will be rendered using the
+    :class:`~kivy.core.text.markup.MarkupLabel`: you can change the style of
+    the text using tags. Check the :doc:`api-kivy.core.text.markup`
+    documentation for more information.
+
+    :attr:`markup` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    def __init__(self, **kwargs):
+        self.register_event_type('on_press')
+        self.register_event_type('on_release')
+        super(ActionPrevious, self).__init__(**kwargs)
+        if not self.app_icon:
+            self.app_icon = 'data/logo/kivy-icon-32.png'
+
+    def on_press(self):
+        pass
+
+    def on_release(self):
+        pass
+
+
+class ActionToggleButton(ActionItem, ToggleButton):
+    '''
+    ActionToggleButton class, see module documentation for more information.
+    '''
+
+    icon = StringProperty(None, allownone=True)
+    '''
+    Source image to use when the Button is part of the ActionBar. If the
+    Button is in a group, the text will be preferred.
+    '''
+
+
+class ActionLabel(ActionItem, Label):
+    '''
+    ActionLabel class, see module documentation for more information.
+    '''
+    pass
+
+
+class ActionCheck(ActionItem, CheckBox):
+    '''
+    ActionCheck class, see module documentation for more information.
+    '''
+    pass
+
+
+class ActionSeparator(ActionItem, Widget):
+    '''
+    ActionSeparator class, see module documentation for more information.
+    '''
+
+    background_image = StringProperty(
+        'atlas://data/images/defaulttheme/separator')
+    '''
+    Background image for the separators default graphical representation.
+
+    :attr:`background_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/separator'.
+    '''
+
+
+class ActionDropDown(DropDown):
+    '''
+    ActionDropDown class, see module documentation for more information.
+    '''
+
+
+class ActionGroup(ActionItem, Button):
+    '''
+    ActionGroup class, see module documentation for more information.
+    '''
+
+    use_separator = BooleanProperty(False)
+    '''
+    Specifies whether to use a separator after/before this group or not.
+
+    :attr:`use_separator` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    separator_image = StringProperty(
+        'atlas://data/images/defaulttheme/separator')
+    '''
+    Background Image for an ActionSeparator in an ActionView.
+
+    :attr:`separator_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/separator'.
+    '''
+
+    separator_width = NumericProperty(0)
+    '''
+    Width of the ActionSeparator in an ActionView.
+
+    :attr:`separator_width` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    mode = OptionProperty('normal', options=('normal', 'spinner'))
+    '''
+    Sets the current mode of an ActionGroup. If mode is 'normal', the
+    ActionGroups children will be displayed normally if there is enough
+    space, otherwise they will be displayed in a spinner. If mode is
+    'spinner', then the children will always be displayed in a spinner.
+
+    :attr:`mode` is an :class:`~kivy.properties.OptionProperty` and defaults
+    to 'normal'.
+    '''
+
+    dropdown_width = NumericProperty(0)
+    '''
+    If non zero, provides the width for the associated DropDown. This is
+    useful when some items in the ActionGroup's DropDown are wider than usual
+    and you don't want to make the ActionGroup widget itself wider.
+
+    :attr:`dropdown_width` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    is_open = BooleanProperty(False)
+    '''By default, the DropDown is not open. Set to True to open it.
+
+    :attr:`is_open` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    def __init__(self, **kwargs):
+        self.list_action_item = []
+        self._list_overflow_items = []
+        super(ActionGroup, self).__init__(**kwargs)
+
+        # real is_open independent on public event
+        self._is_open = False
+
+        # create DropDown for the group and save its state to _is_open
+        self._dropdown = ActionDropDown()
+        self._dropdown.bind(attach_to=lambda ins, value: setattr(
+            self, '_is_open', True if value else False
+        ))
+
+        # put open/close responsibility to the event
+        # - trigger dropdown opening when clicked
+        self.bind(on_release=lambda *args: setattr(
+            self, 'is_open', True
+        ))
+
+        # - trigger dropdown closing when an item
+        #   in the dropdown is clicked
+        self._dropdown.bind(on_dismiss=lambda *args: setattr(
+            self, 'is_open', False
+        ))
+
+    def on_is_open(self, instance, value):
+        # opening only if the DropDown is closed
+        if value and not self._is_open:
+            self._toggle_dropdown()
+            self._dropdown.open(self)
+            return
+
+        # closing is_open manually, dismiss manually
+        if not value and self._is_open:
+            self._dropdown.dismiss()
+
+    def _toggle_dropdown(self, *largs):
+        ddn = self._dropdown
+        ddn.size_hint_x = None
+
+        # if container was set incorrectly and/or is missing
+        if not ddn.container:
+            return
+        children = ddn.container.children
+
+        # set DropDown width manually or if not set, then widen
+        # the ActionGroup + DropDown until the widest child fits
+        if children:
+            ddn.width = self.dropdown_width or max(
+                self.width, max(c.pack_width for c in children)
+            )
+        else:
+            ddn.width = self.width
+
+        # set the DropDown children's height
+        for item in children:
+            item.size_hint_y = None
+            item.height = max([self.height, sp(48)])
+
+            # dismiss DropDown manually
+            # auto_dismiss applies to touching outside of the DropDown
+            item.bind(on_release=ddn.dismiss)
+
+    def add_widget(self, widget, *args, **kwargs):
+        '''
+        .. versionchanged:: 2.1.0
+            Renamed argument `item` to `widget`.
+        '''
+        # if adding ActionSeparator ('normal' mode,
+        # everything visible), add it to the parent
+        if isinstance(widget, ActionSeparator):
+            super(ActionGroup, self).add_widget(widget, *args, **kwargs)
+            return
+
+        if not isinstance(widget, ActionItem):
+            raise ActionBarException('ActionGroup only accepts ActionItem')
+
+        self.list_action_item.append(widget)
+
+    def show_group(self):
+        # 'normal' mode, items can fit to the view
+        self.clear_widgets()
+        for item in self._list_overflow_items + self.list_action_item:
+            item.inside_group = True
+            self._dropdown.add_widget(item)
+
+    def clear_widgets(self, *args, **kwargs):
+        self._dropdown.clear_widgets(*args, **kwargs)
+
+
+class ActionOverflow(ActionGroup):
+    '''
+    ActionOverflow class, see module documentation for more information.
+    '''
+
+    overflow_image = StringProperty(
+        'atlas://data/images/defaulttheme/overflow')
+    '''
+    Image to be used as an Overflow Image.
+
+    :attr:`overflow_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/overflow'.
+    '''
+
+    def add_widget(self, widget, index=0, *args, **kwargs):
+        '''
+        .. versionchanged:: 2.1.0
+             Renamed argument `action_item` to `widget`.
+        '''
+        if widget is None:
+            return
+
+        if isinstance(widget, ActionSeparator):
+            return
+
+        if not isinstance(widget, ActionItem):
+            raise ActionBarException('ActionView only accepts ActionItem'
+                                     ' (got {!r}'.format(widget))
+
+        else:
+            if index == 0:
+                index = len(self._list_overflow_items)
+            self._list_overflow_items.insert(index, widget)
+
+    def show_default_items(self, parent):
+        # display overflow and its items if widget's directly added to it
+        if self._list_overflow_items == []:
+            return
+        self.show_group()
+        super(ActionView, parent).add_widget(self)
+
+
+class ActionView(BoxLayout):
+    '''
+    ActionView class, see module documentation for more information.
+    '''
+
+    action_previous = ObjectProperty(None)
+    '''
+    Previous button for an ActionView.
+
+    :attr:`action_previous` is an :class:`~kivy.properties.ObjectProperty`
+    and defaults to None.
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''
+    Background color in the format (r, g, b, a).
+
+    :attr:`background_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    background_image = StringProperty(
+        'atlas://data/images/defaulttheme/action_view')
+    '''
+    Background image of an ActionViews default graphical representation.
+
+    :attr:`background_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/action_view'.
+    '''
+
+    use_separator = BooleanProperty(False)
+    '''
+    Specify whether to use a separator before every ActionGroup or not.
+
+    :attr:`use_separator` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    overflow_group = ObjectProperty(None)
+    '''
+    Widget to be used for the overflow.
+
+    :attr:`overflow_group` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to an instance of :class:`ActionOverflow`.
+    '''
+
+    def __init__(self, **kwargs):
+        self._list_action_items = []
+        self._list_action_group = []
+        super(ActionView, self).__init__(**kwargs)
+        self._state = ''
+        if not self.overflow_group:
+            self.overflow_group = ActionOverflow(
+                use_separator=self.use_separator)
+
+    def on_action_previous(self, instance, value):
+        self._list_action_items.insert(0, value)
+
+    def add_widget(self, widget, index=0, *args, **kwargs):
+        '''
+        .. versionchanged:: 2.1.0
+            Renamed argument `action_item` to `widget`.
+        '''
+        if widget is None:
+            return
+
+        if not isinstance(widget, ActionItem):
+            raise ActionBarException('ActionView only accepts ActionItem'
+                                     ' (got {!r}'.format(widget))
+
+        elif isinstance(widget, ActionOverflow):
+            self.overflow_group = widget
+            widget.use_separator = self.use_separator
+
+        elif isinstance(widget, ActionGroup):
+            self._list_action_group.append(widget)
+            widget.use_separator = self.use_separator
+
+        elif isinstance(widget, ActionPrevious):
+            self.action_previous = widget
+
+        else:
+            super(ActionView, self).add_widget(widget, index, *args, **kwargs)
+            if index == 0:
+                index = len(self._list_action_items)
+            self._list_action_items.insert(index, widget)
+
+    def on_use_separator(self, instance, value):
+        for group in self._list_action_group:
+            group.use_separator = value
+        if self.overflow_group:
+            self.overflow_group.use_separator = value
+
+    def remove_widget(self, widget, *args, **kwargs):
+        super(ActionView, self).remove_widget(widget, *args, **kwargs)
+        if isinstance(widget, ActionOverflow):
+            for item in widget.list_action_item:
+                if item in self._list_action_items:
+                    self._list_action_items.remove(item)
+
+        if widget in self._list_action_items:
+            self._list_action_items.remove(widget)
+
+    def _clear_all(self):
+        lst = self._list_action_items[:]
+        self.clear_widgets()
+        for group in self._list_action_group:
+            group.clear_widgets()
+
+        self.overflow_group.clear_widgets()
+        self.overflow_group.list_action_item = []
+        self._list_action_items = lst
+
+    def _layout_all(self):
+        # all the items can fit to the view, so expand everything
+        super_add = super(ActionView, self).add_widget
+        self._state = 'all'
+        self._clear_all()
+        if not self.action_previous.parent:
+            super_add(self.action_previous)
+        if len(self._list_action_items) > 1:
+            for child in self._list_action_items[1:]:
+                child.inside_group = False
+                super_add(child)
+
+        for group in self._list_action_group:
+            if group.mode == 'spinner':
+                super_add(group)
+                group.show_group()
+            else:
+                if group.list_action_item != []:
+                    super_add(ActionSeparator())
+                for child in group.list_action_item:
+                    child.inside_group = False
+                    super_add(child)
+
+        self.overflow_group.show_default_items(self)
+
+    def _layout_group(self):
+        # layout all the items in order to pack them per group
+        super_add = super(ActionView, self).add_widget
+        self._state = 'group'
+        self._clear_all()
+        if not self.action_previous.parent:
+            super_add(self.action_previous)
+        if len(self._list_action_items) > 1:
+            for child in self._list_action_items[1:]:
+                super_add(child)
+                child.inside_group = False
+
+        for group in self._list_action_group:
+            super_add(group)
+            group.show_group()
+
+        self.overflow_group.show_default_items(self)
+
+    def _layout_random(self):
+        # layout the items in order to pack all of them grouped, and display
+        # only the action items having 'important'
+        super_add = super(ActionView, self).add_widget
+        self._state = 'random'
+        self._clear_all()
+        hidden_items = []
+        hidden_groups = []
+        total_width = 0
+        if not self.action_previous.parent:
+            super_add(self.action_previous)
+
+        width = (self.width - self.overflow_group.pack_width -
+                 self.action_previous.minimum_width)
+
+        if len(self._list_action_items):
+            for child in self._list_action_items[1:]:
+                if child.important:
+                    if child.pack_width + total_width < width:
+                        super_add(child)
+                        child.inside_group = False
+                        total_width += child.pack_width
+                    else:
+                        hidden_items.append(child)
+                else:
+                    hidden_items.append(child)
+
+        # if space is left then display ActionItem inside their
+        # ActionGroup
+        if total_width < self.width:
+            for group in self._list_action_group:
+                if group.pack_width + total_width +\
+                        group.separator_width < width:
+                    super_add(group)
+                    group.show_group()
+                    total_width += (group.pack_width +
+                                    group.separator_width)
+
+                else:
+                    hidden_groups.append(group)
+        group_index = len(self.children) - 1
+        # if space is left then display other ActionItems
+        if total_width < self.width:
+            for child in hidden_items[:]:
+                if child.pack_width + total_width < width:
+                    super_add(child, group_index)
+                    total_width += child.pack_width
+                    child.inside_group = False
+                    hidden_items.remove(child)
+
+        # for all the remaining ActionItems and ActionItems with in
+        # ActionGroups, Display them inside overflow_group
+        extend_hidden = hidden_items.extend
+        for group in hidden_groups:
+            extend_hidden(group.list_action_item)
+
+        overflow_group = self.overflow_group
+
+        if hidden_items != []:
+            over_add = super(overflow_group.__class__,
+                             overflow_group).add_widget
+            for child in hidden_items:
+                over_add(child)
+
+            overflow_group.show_group()
+            if not self.overflow_group.parent:
+                super_add(overflow_group)
+
+    def on_width(self, width, *args):
+        # determine the layout to use
+
+        # can we display all of them?
+        total_width = 0
+        for child in self._list_action_items:
+            total_width += child.pack_width
+        for group in self._list_action_group:
+            for child in group.list_action_item:
+                total_width += child.pack_width
+        if total_width <= self.width:
+            if self._state != 'all':
+                self._layout_all()
+            return
+
+        # can we display them per group?
+        total_width = 0
+        for child in self._list_action_items:
+            total_width += child.pack_width
+        for group in self._list_action_group:
+            total_width += group.pack_width
+        if total_width < self.width:
+            # ok, we can display all the items grouped
+            if self._state != 'group':
+                self._layout_group()
+            return
+
+        # none of the solutions worked, display them in pack mode
+        self._layout_random()
+
+
+class ContextualActionView(ActionView):
+    '''
+    ContextualActionView class, see the module documentation for more
+    information.
+    '''
+    pass
+
+
+class ActionBar(BoxLayout):
+    '''
+    ActionBar class, which acts as the main container for an
+    :class:`ActionView` instance. The ActionBar determines the overall
+    styling aspects of the bar. :class:`ActionItem`\\s are not added to
+    this class directly, but to the contained :class:`ActionView` instance.
+
+    :Events:
+        `on_previous`
+            Fired when action_previous of action_view is pressed.
+
+    Please see the module documentation for more information.
+    '''
+
+    action_view = ObjectProperty(None)
+    '''
+    action_view of the ActionBar.
+
+    :attr:`action_view` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None or the last ActionView instance added to the ActionBar.
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''
+    Background color, in the format (r, g, b, a).
+
+    :attr:`background_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    background_image = StringProperty(
+        'atlas://data/images/defaulttheme/action_bar')
+
+    '''
+    Background image of the ActionBars default graphical representation.
+
+    :attr:`background_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/action_bar'.
+    '''
+
+    border = ListProperty([2, 2, 2, 2])
+    '''
+    The border to be applied to the :attr:`background_image`.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and defaults to
+    [2, 2, 2, 2]
+    '''
+
+    __events__ = ('on_previous',)
+
+    def __init__(self, **kwargs):
+        super(ActionBar, self).__init__(**kwargs)
+        self._stack_cont_action_view = []
+        self._emit_previous = partial(self.dispatch, 'on_previous')
+
+    def add_widget(self, widget, *args, **kwargs):
+        '''
+        .. versionchanged:: 2.1.0
+            Renamed argument `view` to `widget`.
+        '''
+        if isinstance(widget, ContextualActionView):
+            self._stack_cont_action_view.append(widget)
+            if widget.action_previous is not None:
+                widget.action_previous.unbind(on_release=self._emit_previous)
+                widget.action_previous.bind(on_release=self._emit_previous)
+            self.clear_widgets()
+            super(ActionBar, self).add_widget(widget, *args, **kwargs)
+
+        elif isinstance(widget, ActionView):
+            self.action_view = widget
+            super(ActionBar, self).add_widget(widget, *args, **kwargs)
+
+        else:
+            raise ActionBarException(
+                'ActionBar can only add ContextualActionView or ActionView')
+
+    def on_previous(self, *args):
+        self._pop_contextual_action_view()
+
+    def _pop_contextual_action_view(self):
+        '''Remove the current ContextualActionView and display either the
+           previous one or the ActionView.
+        '''
+        self._stack_cont_action_view.pop()
+        self.clear_widgets()
+        if self._stack_cont_action_view == []:
+            super(ActionBar, self).add_widget(self.action_view)
+        else:
+            super(ActionBar, self).add_widget(self._stack_cont_action_view[-1])
+
+
+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)
diff --git a/kivy/uix/anchorlayout.py b/kivy/uix/anchorlayout.py
new file mode 100644
index 0000000..aa5a7b7
--- /dev/null
+++ b/kivy/uix/anchorlayout.py
@@ -0,0 +1,122 @@
+'''
+Anchor Layout
+=============
+
+.. only:: html
+
+    .. image:: images/anchorlayout.gif
+        :align: right
+
+.. only:: latex
+
+    .. image:: images/anchorlayout.png
+        :align: right
+
+The :class:`AnchorLayout` aligns its children to a border (top, bottom,
+left, right) or center.
+
+
+To draw a button in the lower-right corner::
+
+    layout = AnchorLayout(
+        anchor_x='right', anchor_y='bottom')
+    btn = Button(text='Hello World')
+    layout.add_widget(btn)
+
+'''
+
+__all__ = ('AnchorLayout', )
+
+from kivy.uix.layout import Layout
+from kivy.properties import OptionProperty, VariableListProperty
+
+
+class AnchorLayout(Layout):
+    '''Anchor layout class. See the module documentation for more information.
+    '''
+
+    padding = VariableListProperty([0, 0, 0, 0])
+    '''Padding between the widget box and its children, in pixels:
+    [padding_left, padding_top, padding_right, padding_bottom].
+
+    padding also accepts a two argument form [padding_horizontal,
+    padding_vertical] and a one argument form [padding].
+
+    :attr:`padding` is a :class:`~kivy.properties.VariableListProperty` and
+    defaults to [0, 0, 0, 0].
+    '''
+
+    anchor_x = OptionProperty('center', options=(
+        'left', 'center', 'right'))
+    '''Horizontal anchor.
+
+    :attr:`anchor_x` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'center'. It accepts values of 'left', 'center' or
+    'right'.
+    '''
+
+    anchor_y = OptionProperty('center', options=(
+        'top', 'center', 'bottom'))
+    '''Vertical anchor.
+
+    :attr:`anchor_y` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'center'. It accepts values of 'top', 'center' or
+    'bottom'.
+    '''
+
+    def __init__(self, **kwargs):
+        super(AnchorLayout, self).__init__(**kwargs)
+        fbind = self.fbind
+        update = self._trigger_layout
+        fbind('children', update)
+        fbind('parent', update)
+        fbind('padding', update)
+        fbind('anchor_x', update)
+        fbind('anchor_y', update)
+        fbind('size', update)
+        fbind('pos', update)
+
+    def do_layout(self, *largs):
+        _x, _y = self.pos
+        width = self.width
+        height = self.height
+        anchor_x = self.anchor_x
+        anchor_y = self.anchor_y
+        pad_left, pad_top, pad_right, pad_bottom = self.padding
+
+        for c in self.children:
+            x, y = _x, _y
+            cw, ch = c.size
+            shw, shh = c.size_hint
+            shw_min, shh_min = c.size_hint_min
+            shw_max, shh_max = c.size_hint_max
+
+            if shw is not None:
+                cw = shw * (width - pad_left - pad_right)
+                if shw_min is not None and cw < shw_min:
+                    cw = shw_min
+                elif shw_max is not None and cw > shw_max:
+                    cw = shw_max
+
+            if shh is not None:
+                ch = shh * (height - pad_top - pad_bottom)
+                if shh_min is not None and ch < shh_min:
+                    ch = shh_min
+                elif shh_max is not None and ch > shh_max:
+                    ch = shh_max
+
+            if anchor_x == 'left':
+                x = x + pad_left
+            elif anchor_x == 'right':
+                x = x + width - (cw + pad_right)
+            else:
+                x = x + (width - pad_right + pad_left - cw) / 2
+            if anchor_y == 'bottom':
+                y = y + pad_bottom
+            elif anchor_y == 'top':
+                y = y + height - (ch + pad_top)
+            else:
+                y = y + (height - pad_top + pad_bottom - ch) / 2
+
+            c.pos = x, y
+            c.size = cw, ch
diff --git a/kivy/uix/behaviors/__init__.py b/kivy/uix/behaviors/__init__.py
new file mode 100644
index 0000000..b79c5a3
--- /dev/null
+++ b/kivy/uix/behaviors/__init__.py
@@ -0,0 +1,95 @@
+'''
+Behaviors
+=========
+
+.. versionadded:: 1.8.0
+
+Behavior mixin classes
+----------------------
+
+This module implements behaviors that can be
+`mixed in <https://en.wikipedia.org/wiki/Mixin>`_
+with existing base widgets. The idea behind these classes is to encapsulate
+properties and events associated with certain types of widgets.
+
+Isolating these properties and events in a mixin class allows you to define
+your own implementation for standard kivy widgets that can act as drop-in
+replacements. This means you can re-style and re-define widgets as desired
+without breaking compatibility: as long as they implement the behaviors
+correctly, they can simply replace the standard widgets.
+
+Adding behaviors
+----------------
+
+Say you want to add :class:`~kivy.uix.button.Button` capabilities to an
+:class:`~kivy.uix.image.Image`, you could do::
+
+    class IconButton(ButtonBehavior, Image):
+        pass
+
+This would give you an :class:`~kivy.uix.image.Image` with the events and
+properties inherited from :class:`ButtonBehavior`. For example, the *on_press*
+and *on_release* events would be fired when appropriate::
+
+    class IconButton(ButtonBehavior, Image):
+        def on_press(self):
+            print("on_press")
+
+Or in kv:
+
+.. code-block:: kv
+
+    IconButton:
+        on_press: print('on_press')
+
+Naturally, you could also bind to any property changes the behavior class
+offers:
+
+.. code-block:: python
+
+        def state_changed(*args):
+            print('state changed')
+
+        button = IconButton()
+        button.bind(state=state_changed)
+
+
+.. note::
+
+    The behavior class must always be _before_ the widget class. If you don't
+    specify the inheritance in this order, the behavior will not work because
+    the behavior methods are overwritten by the class method listed first.
+
+    Similarly, if you combine a behavior class with a class which
+    requires the use of the methods also defined by the behavior class, the
+    resulting class may not function properly. For example, when combining the
+    :class:`ButtonBehavior` with a :class:`~kivy.uix.slider.Slider`, both of
+    which use the :meth:`~kivy.uix.widget.Widget.on_touch_up` method,
+    the resulting class may not work properly.
+
+.. versionchanged:: 1.9.1
+
+    The individual behavior classes, previously in one big `behaviors.py`
+    file, has been split into a single file for each class under the
+    :mod:`~kivy.uix.behaviors` module. All the behaviors are still imported
+    in the :mod:`~kivy.uix.behaviors` module so they are accessible as before
+    (e.g. both `from kivy.uix.behaviors import ButtonBehavior` and
+    `from kivy.uix.behaviors.button import ButtonBehavior` work).
+
+'''
+
+__all__ = ('ButtonBehavior', 'ToggleButtonBehavior', 'DragBehavior',
+           'FocusBehavior', 'CompoundSelectionBehavior',
+           'CodeNavigationBehavior', 'EmacsBehavior', 'CoverBehavior',
+           'TouchRippleBehavior', 'TouchRippleButtonBehavior')
+
+from kivy.uix.behaviors.button import ButtonBehavior
+from kivy.uix.behaviors.togglebutton import ToggleButtonBehavior
+from kivy.uix.behaviors.drag import DragBehavior
+from kivy.uix.behaviors.focus import FocusBehavior
+from kivy.uix.behaviors.compoundselection import CompoundSelectionBehavior
+from kivy.uix.behaviors.codenavigation import CodeNavigationBehavior
+from kivy.uix.behaviors.emacs import EmacsBehavior
+from kivy.uix.behaviors.cover import CoverBehavior
+from kivy.uix.behaviors.touchripple import TouchRippleBehavior
+from kivy.uix.behaviors.touchripple import TouchRippleButtonBehavior
diff --git a/kivy/uix/behaviors/__pycache__/__init__.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..9278296
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/button.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/button.cpython-310.pyc
new file mode 100644
index 0000000..c9319f5
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/button.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/codenavigation.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/codenavigation.cpython-310.pyc
new file mode 100644
index 0000000..5b099d5
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/codenavigation.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/compoundselection.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/compoundselection.cpython-310.pyc
new file mode 100644
index 0000000..80c303d
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/compoundselection.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/cover.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/cover.cpython-310.pyc
new file mode 100644
index 0000000..5be6edc
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/cover.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/drag.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/drag.cpython-310.pyc
new file mode 100644
index 0000000..32d9495
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/drag.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/emacs.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/emacs.cpython-310.pyc
new file mode 100644
index 0000000..243b8b6
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/emacs.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/focus.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/focus.cpython-310.pyc
new file mode 100644
index 0000000..9fc14ce
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/focus.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/knspace.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/knspace.cpython-310.pyc
new file mode 100644
index 0000000..cfc10b7
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/knspace.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/togglebutton.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/togglebutton.cpython-310.pyc
new file mode 100644
index 0000000..dd83d92
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/togglebutton.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/__pycache__/touchripple.cpython-310.pyc b/kivy/uix/behaviors/__pycache__/touchripple.cpython-310.pyc
new file mode 100644
index 0000000..55bd7c6
Binary files /dev/null and b/kivy/uix/behaviors/__pycache__/touchripple.cpython-310.pyc differ
diff --git a/kivy/uix/behaviors/button.py b/kivy/uix/behaviors/button.py
new file mode 100644
index 0000000..e6a0558
--- /dev/null
+++ b/kivy/uix/behaviors/button.py
@@ -0,0 +1,212 @@
+'''
+Button Behavior
+===============
+
+The :class:`~kivy.uix.behaviors.button.ButtonBehavior`
+`mixin <https://en.wikipedia.org/wiki/Mixin>`_ class provides
+:class:`~kivy.uix.button.Button` behavior. You can combine this class with
+other widgets, such as an :class:`~kivy.uix.image.Image`, to provide
+alternative buttons that preserve Kivy button behavior.
+
+For an overview of behaviors, please refer to the :mod:`~kivy.uix.behaviors`
+documentation.
+
+Example
+-------
+
+The following example adds button behavior to an image to make a checkbox that
+behaves like a button::
+
+    from kivy.app import App
+    from kivy.uix.image import Image
+    from kivy.uix.behaviors import ButtonBehavior
+
+
+    class MyButton(ButtonBehavior, Image):
+        def __init__(self, **kwargs):
+            super(MyButton, self).__init__(**kwargs)
+            self.source = 'atlas://data/images/defaulttheme/checkbox_off'
+
+        def on_press(self):
+            self.source = 'atlas://data/images/defaulttheme/checkbox_on'
+
+        def on_release(self):
+            self.source = 'atlas://data/images/defaulttheme/checkbox_off'
+
+
+    class SampleApp(App):
+        def build(self):
+            return MyButton()
+
+
+    SampleApp().run()
+
+See :class:`~kivy.uix.behaviors.ButtonBehavior` for details.
+'''
+
+__all__ = ('ButtonBehavior', )
+
+from kivy.clock import Clock
+from kivy.config import Config
+from kivy.properties import OptionProperty, ObjectProperty, \
+    BooleanProperty, NumericProperty
+from time import time
+
+
+class ButtonBehavior(object):
+    '''
+    This `mixin <https://en.wikipedia.org/wiki/Mixin>`_ class provides
+    :class:`~kivy.uix.button.Button` behavior. Please see the
+    :mod:`button behaviors module <kivy.uix.behaviors.button>` documentation
+    for more information.
+
+    :Events:
+        `on_press`
+            Fired when the button is pressed.
+        `on_release`
+            Fired when the button is released (i.e. the touch/click that
+            pressed the button goes away).
+
+    '''
+
+    state = OptionProperty('normal', options=('normal', 'down'))
+    '''The state of the button, must be one of 'normal' or 'down'.
+    The state is 'down' only when the button is currently touched/clicked,
+    otherwise its 'normal'.
+
+    :attr:`state` is an :class:`~kivy.properties.OptionProperty` and defaults
+    to 'normal'.
+    '''
+
+    last_touch = ObjectProperty(None)
+    '''Contains the last relevant touch received by the Button. This can
+    be used in `on_press` or `on_release` in order to know which touch
+    dispatched the event.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`last_touch` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to `None`.
+    '''
+
+    min_state_time = NumericProperty(0)
+    '''The minimum period of time which the widget must remain in the
+    `'down'` state.
+
+    .. versionadded:: 1.9.1
+
+    :attr:`min_state_time` is a float and defaults to 0.035. This value is
+    taken from :class:`~kivy.config.Config`.
+    '''
+
+    always_release = BooleanProperty(False)
+    '''This determines whether or not the widget fires an `on_release` event if
+    the touch_up is outside the widget.
+
+    .. versionadded:: 1.9.0
+
+    .. versionchanged:: 1.10.0
+        The default value is now False.
+
+    :attr:`always_release` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to `False`.
+    '''
+
+    def __init__(self, **kwargs):
+        self.register_event_type('on_press')
+        self.register_event_type('on_release')
+        if 'min_state_time' not in kwargs:
+            self.min_state_time = float(Config.get('graphics',
+                                                   'min_state_time'))
+        super(ButtonBehavior, self).__init__(**kwargs)
+        self.__state_event = None
+        self.__touch_time = None
+        self.fbind('state', self.cancel_event)
+
+    def _do_press(self):
+        self.state = 'down'
+
+    def _do_release(self, *args):
+        self.state = 'normal'
+
+    def cancel_event(self, *args):
+        if self.__state_event:
+            self.__state_event.cancel()
+            self.__state_event = None
+
+    def on_touch_down(self, touch):
+        if super(ButtonBehavior, self).on_touch_down(touch):
+            return True
+        if touch.is_mouse_scrolling:
+            return False
+        if not self.collide_point(touch.x, touch.y):
+            return False
+        if self in touch.ud:
+            return False
+        touch.grab(self)
+        touch.ud[self] = True
+        self.last_touch = touch
+        self.__touch_time = time()
+        self._do_press()
+        self.dispatch('on_press')
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is self:
+            return True
+        if super(ButtonBehavior, self).on_touch_move(touch):
+            return True
+        return self in touch.ud
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return super(ButtonBehavior, self).on_touch_up(touch)
+        assert(self in touch.ud)
+        touch.ungrab(self)
+        self.last_touch = touch
+
+        if (not self.always_release and
+                not self.collide_point(*touch.pos)):
+            self._do_release()
+            return
+
+        touchtime = time() - self.__touch_time
+        if touchtime < self.min_state_time:
+            self.__state_event = Clock.schedule_once(
+                self._do_release, self.min_state_time - touchtime)
+        else:
+            self._do_release()
+        self.dispatch('on_release')
+        return True
+
+    def on_press(self):
+        pass
+
+    def on_release(self):
+        pass
+
+    def trigger_action(self, duration=0.1):
+        '''Trigger whatever action(s) have been bound to the button by calling
+        both the on_press and on_release callbacks.
+
+        This is similar to a quick button press without using any touch events,
+        but note that like most kivy code, this is not guaranteed to be safe to
+        call from external threads. If needed use
+        :class:`Clock <kivy.clock.Clock>` to safely schedule this function and
+        the resulting callbacks to be called from the main thread.
+
+        Duration is the length of the press in seconds. Pass 0 if you want
+        the action to happen instantly.
+
+        .. versionadded:: 1.8.0
+        '''
+        self._do_press()
+        self.dispatch('on_press')
+
+        def trigger_release(dt):
+            self._do_release()
+            self.dispatch('on_release')
+        if not duration:
+            trigger_release(0)
+        else:
+            Clock.schedule_once(trigger_release, duration)
diff --git a/kivy/uix/behaviors/codenavigation.py b/kivy/uix/behaviors/codenavigation.py
new file mode 100644
index 0000000..9fd0be9
--- /dev/null
+++ b/kivy/uix/behaviors/codenavigation.py
@@ -0,0 +1,167 @@
+'''
+Code Navigation Behavior
+========================
+
+The :class:`~kivy.uix.bahviors.CodeNavigationBehavior` modifies navigation
+behavior in the :class:`~kivy.uix.textinput.TextInput`, making it work like an
+IDE instead of a word processor.
+
+Using this mixin gives the TextInput the ability to recognize whitespace,
+punctuation and case variations (e.g. CamelCase) when moving over text. It
+is currently used by the :class:`~kivy.uix.codeinput.CodeInput` widget.
+'''
+
+__all__ = ('CodeNavigationBehavior', )
+
+from kivy.event import EventDispatcher
+import string
+
+
+class CodeNavigationBehavior(EventDispatcher):
+    '''Code navigation behavior. Modifies the navigation behavior in TextInput
+    to work like an IDE instead of a word processor. Please see the
+    :mod:`code navigation behaviors module <kivy.uix.behaviors.codenavigation>`
+    documentation for more information.
+
+    .. versionadded:: 1.9.1
+    '''
+
+    def _move_cursor_word_left(self, index=None):
+        pos = index or self.cursor_index()
+        pos -= 1
+
+        if pos == 0:
+            return 0, 0
+
+        col, row = self.get_cursor_from_index(pos)
+        lines = self._lines
+
+        ucase = string.ascii_uppercase
+        lcase = string.ascii_lowercase
+        ws = string.whitespace
+        punct = string.punctuation
+
+        mode = 'normal'
+
+        rline = lines[row]
+        c = rline[col] if len(rline) > col else '\n'
+        if c in ws:
+            mode = 'ws'
+        elif c == '_':
+            mode = 'us'
+        elif c in punct:
+            mode = 'punct'
+        elif c not in ucase:
+            mode = 'camel'
+
+        while True:
+            if col == -1:
+                if row == 0:
+                    return 0, 0
+                row -= 1
+                rline = lines[row]
+                col = len(rline)
+            lc = c
+            c = rline[col] if len(rline) > col else '\n'
+            if c == '\n':
+                if lc not in ws:
+                    col += 1
+                break
+            if mode in ('normal', 'camel') and c in ws:
+                col += 1
+                break
+            if mode in ('normal', 'camel') and c in punct:
+                col += 1
+                break
+            if mode == 'camel' and c in ucase:
+                break
+            if mode == 'punct' and (c == '_' or c not in punct):
+                col += 1
+                break
+            if mode == 'us' and c != '_' and (c in punct or c in ws):
+                col += 1
+                break
+
+            if mode == 'us' and c != '_':
+                mode = ('normal' if c in ucase
+                        else 'ws' if c in ws
+                else 'camel')
+            elif mode == 'ws' and c not in ws:
+                mode = ('normal' if c in ucase
+                        else 'us' if c == '_'
+                else 'punct' if c in punct
+                else 'camel')
+
+            col -= 1
+
+        if col > len(rline):
+            if row == len(lines) - 1:
+                return row, len(lines[row])
+            row += 1
+            col = 0
+
+        return col, row
+
+    def _move_cursor_word_right(self, index=None):
+        pos = index or self.cursor_index()
+        col, row = self.get_cursor_from_index(pos)
+        lines = self._lines
+        mrow = len(lines) - 1
+
+        if row == mrow and col == len(lines[row]):
+            return col, row
+
+        ucase = string.ascii_uppercase
+        lcase = string.ascii_lowercase
+        ws = string.whitespace
+        punct = string.punctuation
+
+        mode = 'normal'
+
+        rline = lines[row]
+        c = rline[col] if len(rline) > col else '\n'
+        if c in ws:
+            mode = 'ws'
+        elif c == '_':
+            mode = 'us'
+        elif c in punct:
+            mode = 'punct'
+        elif c in lcase:
+            mode = 'camel'
+
+        while True:
+            if mode in ('normal', 'camel', 'punct') and c in ws:
+                mode = 'ws'
+            elif mode in ('normal', 'camel') and c == '_':
+                mode = 'us'
+            elif mode == 'normal' and c not in ucase:
+                mode = 'camel'
+
+            if mode == 'us':
+                if c in ws:
+                    mode = 'ws'
+                elif c != '_':
+                    break
+            if mode == 'ws' and c not in ws:
+                break
+            if mode == 'camel' and c in ucase:
+                break
+            if mode == 'punct' and (c == '_' or c not in punct):
+                break
+            if mode != 'punct' and c != '_' and c in punct:
+                break
+
+            col += 1
+
+            if col > len(rline):
+                if row == mrow:
+                    return len(rline), mrow
+                row += 1
+                rline = lines[row]
+                col = 0
+
+            c = rline[col] if len(rline) > col else '\n'
+            if c == '\n':
+                break
+
+        return col, row
diff --git a/kivy/uix/behaviors/compoundselection.py b/kivy/uix/behaviors/compoundselection.py
new file mode 100644
index 0000000..6c7d0a2
--- /dev/null
+++ b/kivy/uix/behaviors/compoundselection.py
@@ -0,0 +1,689 @@
+'''
+Compound Selection Behavior
+===========================
+
+The :class:`~kivy.uix.behaviors.compoundselection.CompoundSelectionBehavior`
+`mixin <https://en.wikipedia.org/wiki/Mixin>`_ class implements the logic
+behind keyboard and touch selection of selectable widgets managed by the
+derived widget. For example, it can be combined with a
+:class:`~kivy.uix.gridlayout.GridLayout` to add selection to the layout.
+
+Compound selection concepts
+---------------------------
+
+At its core, it keeps a dynamic list of widgets that can be selected.
+Then, as the touches and keyboard input are passed in, it selects one or
+more of the widgets based on these inputs. For example, it uses the mouse
+scroll and keyboard up/down buttons to scroll through the list of widgets.
+Multiselection can also be achieved using the keyboard shift and ctrl keys.
+
+Finally, in addition to the up/down type keyboard inputs, compound selection
+can also accept letters from the keyboard to be used to select nodes with
+associated strings that start with those letters, similar to how files
+are selected by a file browser.
+
+Selection mechanics
+-------------------
+
+When the controller needs to select a node, it calls :meth:`select_node` and
+:meth:`deselect_node`. Therefore, they must be overwritten in order alter
+node selection. By default, the class doesn't listen for keyboard or
+touch events, so the derived widget must call
+:meth:`select_with_touch`, :meth:`select_with_key_down`, and
+:meth:`select_with_key_up` on events that it wants to pass on for selection
+purposes.
+
+Example
+-------
+
+To add selection to a grid layout which will contain
+:class:`~kivy.uix.Button` widgets. For each button added to the layout, you
+need to bind the :attr:`~kivy.uix.widget.Widget.on_touch_down` of the button
+to :meth:`select_with_touch` to pass on the touch events::
+
+    from kivy.uix.behaviors.compoundselection import CompoundSelectionBehavior
+    from kivy.uix.button import Button
+    from kivy.uix.gridlayout import GridLayout
+    from kivy.uix.behaviors import FocusBehavior
+    from kivy.core.window import Window
+    from kivy.app import App
+
+
+    class SelectableGrid(FocusBehavior, CompoundSelectionBehavior, GridLayout):
+
+        def keyboard_on_key_down(self, window, keycode, text, modifiers):
+            """Based on FocusBehavior that provides automatic keyboard
+            access, key presses will be used to select children.
+            """
+            if super(SelectableGrid, self).keyboard_on_key_down(
+                window, keycode, text, modifiers):
+                return True
+            if self.select_with_key_down(window, keycode, text, modifiers):
+                return True
+            return False
+
+        def keyboard_on_key_up(self, window, keycode):
+            """Based on FocusBehavior that provides automatic keyboard
+            access, key release will be used to select children.
+            """
+            if super(SelectableGrid, self).keyboard_on_key_up(window, keycode):
+                return True
+            if self.select_with_key_up(window, keycode):
+                return True
+            return False
+
+        def add_widget(self, widget, *args, **kwargs):
+            """ Override the adding of widgets so we can bind and catch their
+            *on_touch_down* events. """
+            widget.bind(on_touch_down=self.button_touch_down,
+                        on_touch_up=self.button_touch_up)
+            return super(SelectableGrid, self)\
+                .add_widget(widget, *args, **kwargs)
+
+        def button_touch_down(self, button, touch):
+            """ Use collision detection to select buttons when the touch occurs
+            within their area. """
+            if button.collide_point(*touch.pos):
+                self.select_with_touch(button, touch)
+
+        def button_touch_up(self, button, touch):
+            """ Use collision detection to de-select buttons when the touch
+            occurs outside their area and *touch_multiselect* is not True. """
+            if not (button.collide_point(*touch.pos) or
+                    self.touch_multiselect):
+                self.deselect_node(button)
+
+        def select_node(self, node):
+            node.background_color = (1, 0, 0, 1)
+            return super(SelectableGrid, self).select_node(node)
+
+        def deselect_node(self, node):
+            node.background_color = (1, 1, 1, 1)
+            super(SelectableGrid, self).deselect_node(node)
+
+        def on_selected_nodes(self, grid, nodes):
+            print("Selected nodes = {0}".format(nodes))
+
+
+    class TestApp(App):
+        def build(self):
+            grid = SelectableGrid(cols=3, rows=2, touch_multiselect=True,
+                                  multiselect=True)
+            for i in range(0, 6):
+                grid.add_widget(Button(text="Button {0}".format(i)))
+            return grid
+
+
+    TestApp().run()
+
+
+.. warning::
+
+    This code is still experimental, and its API is subject to change in a
+    future version.
+
+'''
+
+__all__ = ('CompoundSelectionBehavior', )
+
+from time import time
+from os import environ
+
+from kivy.properties import NumericProperty, BooleanProperty, ListProperty
+
+
+if 'KIVY_DOC' not in environ:
+    from kivy.config import Config
+    _is_desktop = Config.getboolean('kivy', 'desktop')
+else:
+    _is_desktop = False
+
+
+class CompoundSelectionBehavior(object):
+    '''The Selection behavior `mixin <https://en.wikipedia.org/wiki/Mixin>`_
+    implements the logic behind keyboard and touch
+    selection of selectable widgets managed by the derived widget. Please see
+    the :mod:`compound selection behaviors module
+    <kivy.uix.behaviors.compoundselection>` documentation
+    for more information.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    selected_nodes = ListProperty([])
+    '''The list of selected nodes.
+
+    .. note::
+
+        Multiple nodes can be selected right after one another e.g. using the
+        keyboard. When listening to :attr:`selected_nodes`, one should be
+        aware of this.
+
+    :attr:`selected_nodes` is a :class:`~kivy.properties.ListProperty` and
+    defaults to the empty list, []. It is read-only and should not be modified.
+    '''
+
+    touch_multiselect = BooleanProperty(False)
+    '''A special touch mode which determines whether touch events, as
+    processed by :meth:`select_with_touch`, will add the currently touched
+    node to the selection, or if it will clear the selection before adding the
+    node. This allows the selection of multiple nodes by simply touching them.
+
+    This is different from :attr:`multiselect` because when it is True,
+    simply touching an unselected node will select it, even if ctrl is not
+    pressed. If it is False, however, ctrl must be pressed in order to
+    add to the selection when :attr:`multiselect` is True.
+
+    .. note::
+
+        :attr:`multiselect`, when False, will disable
+        :attr:`touch_multiselect`.
+
+    :attr:`touch_multiselect` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to False.
+    '''
+
+    multiselect = BooleanProperty(False)
+    '''Determines whether multiple nodes can be selected. If enabled, keyboard
+    shift and ctrl selection, optionally combined with touch, for example, will
+    be able to select multiple widgets in the normally expected manner.
+    This dominates :attr:`touch_multiselect` when False.
+
+    :attr:`multiselect` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    touch_deselect_last = BooleanProperty(not _is_desktop)
+    '''Determines whether the last selected node can be deselected when
+    :attr:`multiselect` or :attr:`touch_multiselect` is False.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`touch_deselect_last` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True on mobile, False on desktop platforms.
+    '''
+
+    keyboard_select = BooleanProperty(True)
+    '''Determines whether the keyboard can be used for selection. If False,
+    keyboard inputs will be ignored.
+
+    :attr:`keyboard_select` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True.
+    '''
+
+    page_count = NumericProperty(10)
+    '''Determines by how much the selected node is moved up or down, relative
+    to the position of the last selected node, when pageup (or pagedown) is
+    pressed.
+
+    :attr:`page_count` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 10.
+    '''
+
+    up_count = NumericProperty(1)
+    '''Determines by how much the selected node is moved up or down, relative
+    to the position of the last selected node, when the up (or down) arrow on
+    the keyboard is pressed.
+
+    :attr:`up_count` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+    '''
+
+    right_count = NumericProperty(1)
+    '''Determines by how much the selected node is moved up or down, relative
+    to the position of the last selected node, when the right (or left) arrow
+    on the keyboard is pressed.
+
+    :attr:`right_count` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+    '''
+
+    scroll_count = NumericProperty(0)
+    '''Determines by how much the selected node is moved up or down, relative
+    to the position of the last selected node, when the mouse scroll wheel is
+    scrolled.
+
+    :attr:`right_count` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    nodes_order_reversed = BooleanProperty(True)
+    ''' (Internal) Indicates whether the order of the nodes as displayed top-
+    down is reversed compared to their order in :meth:`get_selectable_nodes`
+    (e.g. how the children property is reversed compared to how
+    it's displayed).
+    '''
+
+    text_entry_timeout = NumericProperty(1.)
+    '''When typing characters in rapid succession (i.e. the time difference since
+    the last character is less than :attr:`text_entry_timeout`), the keys get
+    concatenated and the combined text is passed as the key argument of
+    :meth:`goto_node`.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    _anchor = None  # the last anchor node selected (e.g. shift relative node)
+    # the idx may be out of sync
+    _anchor_idx = 0  # cache indexs in case list hasn't changed
+    _last_selected_node = None  # the absolute last node selected
+    _last_node_idx = 0
+    _ctrl_down = False  # if it's pressed - for e.g. shift selection
+    _shift_down = False
+    # holds str used to find node, e.g. if word is typed. passed to goto_node
+    _word_filter = ''
+    _last_key_time = 0  # time since last press, for finding whole strs in node
+    _key_list = []  # keys that are already pressed, to not press continuously
+    _offset_counts = {}  # cache of counts for faster access
+
+    def __init__(self, **kwargs):
+        super(CompoundSelectionBehavior, self).__init__(**kwargs)
+        self._key_list = []
+
+        def ensure_single_select(*l):
+            if (not self.multiselect) and len(self.selected_nodes) > 1:
+                self.clear_selection()
+        update_counts = self._update_counts
+        update_counts()
+        fbind = self.fbind
+        fbind('multiselect', ensure_single_select)
+        fbind('page_count', update_counts)
+        fbind('up_count', update_counts)
+        fbind('right_count', update_counts)
+        fbind('scroll_count', update_counts)
+
+    def select_with_touch(self, node, touch=None):
+        '''(internal) Processes a touch on the node. This should be called by
+        the derived widget when a node is touched and is to be used for
+        selection. Depending on the keyboard keys pressed and the
+        configuration, it could select or deslect this and other nodes in the
+        selectable nodes list, :meth:`get_selectable_nodes`.
+
+        :Parameters:
+            `node`
+                The node that received the touch. Can be None for a scroll
+                type touch.
+            `touch`
+                Optionally, the touch. Defaults to None.
+
+        :Returns:
+            bool, True if the touch was used, False otherwise.
+        '''
+        multi = self.multiselect
+        multiselect = multi and (self._ctrl_down or self.touch_multiselect)
+        range_select = multi and self._shift_down
+
+        if touch and 'button' in touch.profile and touch.button in\
+            ('scrollup', 'scrolldown', 'scrollleft', 'scrollright'):
+            node_src, idx_src = self._resolve_last_node()
+            node, idx = self.goto_node(touch.button, node_src, idx_src)
+            if node == node_src:
+                return False
+            if range_select:
+                self._select_range(multiselect, True, node, idx)
+            else:
+                if not multiselect:
+                    self.clear_selection()
+                self.select_node(node)
+            return True
+        if node is None:
+            return False
+
+        if (node in self.selected_nodes and (not range_select)):  # selected
+            if multiselect:
+                self.deselect_node(node)
+            else:
+                selected_node_count = len(self.selected_nodes)
+                self.clear_selection()
+                if not self.touch_deselect_last or selected_node_count > 1:
+                    self.select_node(node)
+        elif range_select:
+            # keep anchor only if not multiselect (ctrl-type selection)
+            self._select_range(multiselect, not multiselect, node, 0)
+        else:   # it's not selected at this point
+            if not multiselect:
+                self.clear_selection()
+            self.select_node(node)
+        return True
+
+    def select_with_key_down(self, keyboard, scancode, codepoint, modifiers,
+                             **kwargs):
+        '''Processes a key press. This is called when a key press is to be used
+        for selection. Depending on the keyboard keys pressed and the
+        configuration, it could select or deselect nodes or node ranges
+        from the selectable nodes list, :meth:`get_selectable_nodes`.
+
+        The parameters are such that it could be bound directly to the
+        on_key_down event of a keyboard. Therefore, it is safe to be called
+        repeatedly when the key is held down as is done by the keyboard.
+
+        :Returns:
+            bool, True if the keypress was used, False otherwise.
+        '''
+        if not self.keyboard_select:
+            return False
+        keys = self._key_list
+        multi = self.multiselect
+        node_src, idx_src = self._resolve_last_node()
+        text = scancode[1]
+
+        if text == 'shift':
+            self._shift_down = True
+        elif text in ('ctrl', 'lctrl', 'rctrl'):
+            self._ctrl_down = True
+        elif (multi and 'ctrl' in modifiers and text in ('a', 'A') and
+              text not in keys):
+            sister_nodes = self.get_selectable_nodes()
+            select = self.select_node
+            for node in sister_nodes:
+                select(node)
+            keys.append(text)
+        else:
+            s = text
+            if len(text) > 1:
+                d = {'divide': '/', 'mul': '*', 'substract': '-', 'add': '+',
+                     'decimal': '.'}
+                if text.startswith('numpad'):
+                    s = text[6:]
+                    if len(s) > 1:
+                        if s in d:
+                            s = d[s]
+                        else:
+                            s = None
+                else:
+                    s = None
+
+            if s is not None:
+                if s not in keys:  # don't keep adding while holding down
+                    if time() - self._last_key_time <= self.text_entry_timeout:
+                        self._word_filter += s
+                    else:
+                        self._word_filter = s
+                    keys.append(s)
+
+                self._last_key_time = time()
+                node, idx = self.goto_node(self._word_filter, node_src,
+                                           idx_src)
+            else:
+                self._word_filter = ''
+                node, idx = self.goto_node(text, node_src, idx_src)
+
+            if node == node_src:
+                return False
+
+            multiselect = multi and 'ctrl' in modifiers
+            if multi and 'shift' in modifiers:
+                self._select_range(multiselect, True, node, idx)
+            else:
+                if not multiselect:
+                    self.clear_selection()
+                self.select_node(node)
+            return True
+        self._word_filter = ''
+        return False
+
+    def select_with_key_up(self, keyboard, scancode, **kwargs):
+        '''(internal) Processes a key release. This must be called by the
+        derived widget when a key that :meth:`select_with_key_down` returned
+        True is released.
+
+        The parameters are such that it could be bound directly to the
+        on_key_up event of a keyboard.
+
+        :Returns:
+            bool, True if the key release was used, False otherwise.
+        '''
+        if scancode[1] == 'shift':
+            self._shift_down = False
+        elif scancode[1] in ('ctrl', 'lctrl', 'rctrl'):
+            self._ctrl_down = False
+        else:
+            try:
+                self._key_list.remove(scancode[1])
+                return True
+            except ValueError:
+                return False
+        return True
+
+    def _update_counts(self, *largs):
+        # doesn't invert indices here
+        pc = self.page_count
+        uc = self.up_count
+        rc = self.right_count
+        sc = self.scroll_count
+        self._offset_counts = {'pageup': -pc, 'pagedown': pc, 'up': -uc,
+        'down': uc, 'right': rc, 'left': -rc, 'scrollup': sc,
+        'scrolldown': -sc, 'scrollright': -sc, 'scrollleft': sc}
+
+    def _resolve_last_node(self):
+        # for offset selection, we have a anchor, and we select everything
+        # between anchor and added offset relative to last node
+        sister_nodes = self.get_selectable_nodes()
+        if not len(sister_nodes):
+            return None, 0
+        last_node = self._last_selected_node
+        last_idx = self._last_node_idx
+        end = len(sister_nodes) - 1
+
+        if last_node is None:
+            last_node = self._anchor
+            last_idx = self._anchor_idx
+        if last_node is None:
+            return sister_nodes[end], end
+        if last_idx > end or sister_nodes[last_idx] != last_node:
+            try:
+                return last_node, self.get_index_of_node(last_node,
+                                                         sister_nodes)
+            except ValueError:
+                return sister_nodes[end], end
+        return last_node, last_idx
+
+    def _select_range(self, multiselect, keep_anchor, node, idx):
+        '''Selects a range between self._anchor and node or idx.
+        If multiselect is True, it will be added to the selection, otherwise
+        it will unselect everything before selecting the range. This is only
+        called if self.multiselect is True.
+        If keep anchor is False, the anchor is moved to node. This should
+        always be True for keyboard selection.
+        '''
+        select = self.select_node
+        sister_nodes = self.get_selectable_nodes()
+        end = len(sister_nodes) - 1
+        last_node = self._anchor
+        last_idx = self._anchor_idx
+
+        if last_node is None:
+            last_idx = end
+            last_node = sister_nodes[end]
+        else:
+            if last_idx > end or sister_nodes[last_idx] != last_node:
+                try:
+                    last_idx = self.get_index_of_node(last_node, sister_nodes)
+                except ValueError:
+                    # list changed - cannot do select across them
+                    return
+        if idx > end or sister_nodes[idx] != node:
+            try:    # just in case
+                idx = self.get_index_of_node(node, sister_nodes)
+            except ValueError:
+                return
+
+        if last_idx > idx:
+            last_idx, idx = idx, last_idx
+        if not multiselect:
+            self.clear_selection()
+        for item in sister_nodes[last_idx:idx + 1]:
+            select(item)
+
+        if keep_anchor:
+            self._anchor = last_node
+            self._anchor_idx = last_idx
+        else:
+            self._anchor = node  # in case idx was reversed, reset
+            self._anchor_idx = idx
+        self._last_selected_node = node
+        self._last_node_idx = idx
+
+    def clear_selection(self):
+        ''' Deselects all the currently selected nodes.
+        '''
+        # keep the anchor and last selected node
+        deselect = self.deselect_node
+        nodes = self.selected_nodes
+        # empty beforehand so lookup in deselect will be fast
+        for node in nodes[:]:
+            deselect(node)
+
+    def get_selectable_nodes(self):
+        '''(internal) Returns a list of the nodes that can be selected. It can
+        be overwritten by the derived widget to return the correct list.
+
+        This list is used to determine which nodes to select with group
+        selection. E.g. the last element in the list will be selected when
+        home is pressed, pagedown will move (or add to, if shift is held) the
+        selection from the current position by negative :attr:`page_count`
+        nodes starting from the position of the currently selected node in
+        this list and so on. Still, nodes can be selected even if they are not
+        in this list.
+
+        .. note::
+
+            It is safe to dynamically change this list including removing,
+            adding, or re-arranging its elements. Nodes can be selected even
+            if they are not on this list. And selected nodes removed from the
+            list will remain selected until :meth:`deselect_node` is called.
+
+        .. warning::
+
+            Layouts display their children in the reverse order. That is, the
+            contents of :attr:`~kivy.uix.widget.Widget.children` is displayed
+            form right to left, bottom to top. Therefore, internally, the
+            indices of the elements returned by this function are reversed to
+            make it work by default for most layouts so that the final result
+            is consistent e.g. home, although it will select the last element
+            in this list visually, will select the first element when
+            counting from top to bottom and left to right. If this behavior is
+            not desired, a reversed list should be returned instead.
+
+        Defaults to returning :attr:`~kivy.uix.widget.Widget.children`.
+        '''
+        return self.children
+
+    def get_index_of_node(self, node, selectable_nodes):
+        '''(internal) Returns the index of the `node` within the
+        `selectable_nodes` returned by :meth:`get_selectable_nodes`.
+        '''
+        return selectable_nodes.index(node)
+
+    def goto_node(self, key, last_node, last_node_idx):
+        '''(internal) Used by the controller to get the node at the position
+        indicated by key. The key can be keyboard inputs, e.g. pageup,
+        or scroll inputs from the mouse scroll wheel, e.g. scrollup.
+        'last_node' is the last node selected and is used to find the resulting
+        node. For example, if the key is up, the returned node is one node
+        up from the last node.
+
+        It can be overwritten by the derived widget.
+
+        :Parameters:
+            `key`
+                str, the string used to find the desired node. It can be any
+                of the keyboard keys, as well as the mouse scrollup,
+                scrolldown, scrollright, and scrollleft strings. If letters
+                are typed in quick succession, the letters will be combined
+                before it's passed in as key and can be used to find nodes that
+                have an associated string that starts with those letters.
+            `last_node`
+                The last node that was selected.
+            `last_node_idx`
+                The cached index of the last node selected in the
+                :meth:`get_selectable_nodes` list. If the list hasn't changed
+                it saves having to look up the index of `last_node` in that
+                list.
+
+        :Returns:
+            tuple, the node targeted by key and its index in the
+            :meth:`get_selectable_nodes` list. Returning
+            `(last_node, last_node_idx)` indicates a node wasn't found.
+        '''
+        sister_nodes = self.get_selectable_nodes()
+        end = len(sister_nodes) - 1
+        counts = self._offset_counts
+        if end == -1:
+            return last_node, last_node_idx
+        if last_node_idx > end or sister_nodes[last_node_idx] != last_node:
+            try:    # just in case
+                last_node_idx = self.get_index_of_node(last_node, sister_nodes)
+            except ValueError:
+                return last_node, last_node_idx
+
+        is_reversed = self.nodes_order_reversed
+        if key in counts:
+            count = -counts[key] if is_reversed else counts[key]
+            idx = max(min(count + last_node_idx, end), 0)
+            return sister_nodes[idx], idx
+        elif key == 'home':
+            if is_reversed:
+                return sister_nodes[end], end
+            return sister_nodes[0], 0
+        elif key == 'end':
+            if is_reversed:
+                return sister_nodes[0], 0
+            return sister_nodes[end], end
+        else:
+            return last_node, last_node_idx
+
+    def select_node(self, node):
+        ''' Selects a node.
+
+        It is called by the controller when it selects a node and can be
+        called from the outside to select a node directly. The derived widget
+        should overwrite this method and change the node state to selected
+        when called.
+
+        :Parameters:
+            `node`
+                The node to be selected.
+
+        :Returns:
+            bool, True if the node was selected, False otherwise.
+
+        .. warning::
+
+            This method must be called by the derived widget using super if it
+            is overwritten.
+        '''
+        nodes = self.selected_nodes
+        if node in nodes:
+            return False
+
+        if (not self.multiselect) and len(nodes):
+            self.clear_selection()
+        if node not in nodes:
+            nodes.append(node)
+        self._anchor = node
+        self._last_selected_node = node
+        return True
+
+    def deselect_node(self, node):
+        ''' Deselects a possibly selected node.
+
+        It is called by the controller when it deselects a node and can also
+        be called from the outside to deselect a node directly. The derived
+        widget should overwrite this method and change the node to its
+        unselected state when this is called
+
+        :Parameters:
+            `node`
+                The node to be deselected.
+
+        .. warning::
+
+            This method must be called by the derived widget using super if it
+            is overwritten.
+        '''
+        try:
+            self.selected_nodes.remove(node)
+            return True
+        except ValueError:
+            return False
diff --git a/kivy/uix/behaviors/cover.py b/kivy/uix/behaviors/cover.py
new file mode 100644
index 0000000..2e573c1
--- /dev/null
+++ b/kivy/uix/behaviors/cover.py
@@ -0,0 +1,160 @@
+'''
+Cover Behavior
+==============
+
+The :class:`~kivy.uix.behaviors.cover.CoverBehavior`
+`mixin <https://en.wikipedia.org/wiki/Mixin>`_ is intended for rendering
+textures to full widget size keeping the aspect ratio of the original texture.
+
+Use cases are i.e. rendering full size background images or video content in
+a dynamic layout.
+
+For an overview of behaviors, please refer to the :mod:`~kivy.uix.behaviors`
+documentation.
+
+Example
+-------
+
+The following examples add cover behavior to an image:
+
+In python:
+
+.. code-block:: python
+
+    from kivy.app import App
+    from kivy.uix.behaviors import CoverBehavior
+    from kivy.uix.image import Image
+
+
+    class CoverImage(CoverBehavior, Image):
+
+        def __init__(self, **kwargs):
+            super(CoverImage, self).__init__(**kwargs)
+            texture = self._coreimage.texture
+            self.reference_size = texture.size
+            self.texture = texture
+
+
+    class MainApp(App):
+
+        def build(self):
+            return CoverImage(source='image.jpg')
+
+    MainApp().run()
+
+In Kivy Language:
+
+.. code-block:: kv
+
+    CoverImage:
+        source: 'image.png'
+
+    <CoverImage@CoverBehavior+Image>:
+        reference_size: self.texture_size
+
+See :class:`~kivy.uix.behaviors.cover.CoverBehavior` for details.
+'''
+
+__all__ = ('CoverBehavior', )
+
+from decimal import Decimal
+from kivy.lang import Builder
+from kivy.properties import ListProperty
+
+
+Builder.load_string("""
+<-CoverBehavior>:
+    canvas.before:
+        StencilPush
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        StencilUse
+    canvas:
+        Rectangle:
+            texture: self.texture
+            size: self.cover_size
+            pos: self.cover_pos
+    canvas.after:
+        StencilUnUse
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        StencilPop
+""")
+
+
+class CoverBehavior(object):
+    '''The CoverBehavior `mixin <https://en.wikipedia.org/wiki/Mixin>`_
+    provides rendering a texture covering full widget size keeping aspect ratio
+    of the original texture.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    reference_size = ListProperty([])
+    '''Reference size used for aspect ratio approximation calculation.
+
+    :attr:`reference_size` is a :class:`~kivy.properties.ListProperty` and
+    defaults to `[]`.
+    '''
+
+    cover_size = ListProperty([0, 0])
+    '''Size of the aspect ratio aware texture. Gets calculated in
+    ``CoverBehavior.calculate_cover``.
+
+    :attr:`cover_size` is a :class:`~kivy.properties.ListProperty` and
+    defaults to `[0, 0]`.
+    '''
+
+    cover_pos = ListProperty([0, 0])
+    '''Position of the aspect ratio aware texture. Gets calculated in
+    ``CoverBehavior.calculate_cover``.
+
+    :attr:`cover_pos` is a :class:`~kivy.properties.ListProperty` and
+    defaults to `[0, 0]`.
+    '''
+
+    def __init__(self, **kwargs):
+        super(CoverBehavior, self).__init__(**kwargs)
+        # bind covering
+        self.bind(
+            size=self.calculate_cover,
+            pos=self.calculate_cover
+        )
+
+    def _aspect_ratio_approximate(self, size):
+        # return a decimal approximation of an aspect ratio.
+        return Decimal('%.2f' % (float(size[0]) / size[1]))
+
+    def _scale_size(self, size, sizer):
+        # return scaled size based on sizer, where sizer (n, None) scales x
+        # to n and (None, n) scales y to n
+        size_new = list(sizer)
+        i = size_new.index(None)
+        j = i * -1 + 1
+        size_new[i] = (size_new[j] * size[i]) / size[j]
+        return tuple(size_new)
+
+    def calculate_cover(self, *args):
+        # return if no reference size yet
+        if not self.reference_size:
+            return
+        size = self.size
+        origin_appr = self._aspect_ratio_approximate(self.reference_size)
+        crop_appr = self._aspect_ratio_approximate(size)
+        # same aspect ratio
+        if origin_appr == crop_appr:
+            crop_size = self.size
+            offset = (0, 0)
+        # scale x
+        elif origin_appr < crop_appr:
+            crop_size = self._scale_size(self.reference_size, (size[0], None))
+            offset = (0, ((crop_size[1] - size[1]) / 2) * -1)
+        # scale y
+        else:
+            crop_size = self._scale_size(self.reference_size, (None, size[1]))
+            offset = (((crop_size[0] - size[0]) / 2) * -1, 0)
+        # set background size and position
+        self.cover_size = crop_size
+        self.cover_pos = offset
diff --git a/kivy/uix/behaviors/drag.py b/kivy/uix/behaviors/drag.py
new file mode 100644
index 0000000..034af05
--- /dev/null
+++ b/kivy/uix/behaviors/drag.py
@@ -0,0 +1,234 @@
+"""
+Drag Behavior
+=============
+
+The :class:`~kivy.uix.behaviors.drag.DragBehavior`
+`mixin <https://en.wikipedia.org/wiki/Mixin>`_ class provides Drag behavior.
+When combined with a widget, dragging in the rectangle defined by the
+:attr:`~kivy.uix.behaviors.drag.DragBehavior.drag_rectangle` will drag the
+widget.
+
+Example
+-------
+
+The following example creates a draggable label::
+
+    from kivy.uix.label import Label
+    from kivy.app import App
+    from kivy.uix.behaviors import DragBehavior
+    from kivy.lang import Builder
+
+    # You could also put the following in your kv file...
+    kv = '''
+    <DragLabel>:
+        # Define the properties for the DragLabel
+        drag_rectangle: self.x, self.y, self.width, self.height
+        drag_timeout: 10000000
+        drag_distance: 0
+
+    FloatLayout:
+        # Define the root widget
+        DragLabel:
+            size_hint: 0.25, 0.2
+            text: 'Drag me'
+    '''
+
+
+    class DragLabel(DragBehavior, Label):
+        pass
+
+
+    class TestApp(App):
+        def build(self):
+            return Builder.load_string(kv)
+
+    TestApp().run()
+
+"""
+
+__all__ = ('DragBehavior', )
+
+from kivy.clock import Clock
+from kivy.properties import NumericProperty, ReferenceListProperty
+from kivy.config import Config
+from kivy.metrics import sp
+from functools import partial
+
+# When we are generating documentation, Config doesn't exist
+_scroll_timeout = _scroll_distance = 0
+if Config:
+    _scroll_timeout = Config.getint('widgets', 'scroll_timeout')
+    _scroll_distance = Config.getint('widgets', 'scroll_distance')
+
+
+class DragBehavior(object):
+    '''
+    The DragBehavior `mixin <https://en.wikipedia.org/wiki/Mixin>`_ provides
+    Drag behavior. When combined with a widget, dragging in the rectangle
+    defined by :attr:`drag_rectangle` will drag the widget. Please see
+    the :mod:`drag behaviors module <kivy.uix.behaviors.drag>` documentation
+    for more information.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    drag_distance = NumericProperty(_scroll_distance)
+    '''Distance to move before dragging the :class:`DragBehavior`, in pixels.
+    As soon as the distance has been traveled, the :class:`DragBehavior` will
+    start to drag, and no touch event will be dispatched to the children.
+    It is advisable that you base this value on the dpi of your target device's
+    screen.
+
+    :attr:`drag_distance` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to the `scroll_distance` as defined in the user
+    :class:`~kivy.config.Config` (20 pixels by default).
+    '''
+
+    drag_timeout = NumericProperty(_scroll_timeout)
+    '''Timeout allowed to trigger the :attr:`drag_distance`, in milliseconds.
+    If the user has not moved :attr:`drag_distance` within the timeout,
+    dragging will be disabled, and the touch event will be dispatched to the
+    children.
+
+    :attr:`drag_timeout` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to the `scroll_timeout` as defined in the user
+    :class:`~kivy.config.Config` (55 milliseconds by default).
+    '''
+
+    drag_rect_x = NumericProperty(0)
+    '''X position of the axis aligned bounding rectangle where dragging
+    is allowed (in window coordinates).
+
+    :attr:`drag_rect_x` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    drag_rect_y = NumericProperty(0)
+    '''Y position of the axis aligned bounding rectangle where dragging
+    is allowed (in window coordinates).
+
+    :attr:`drag_rect_Y` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    drag_rect_width = NumericProperty(100)
+    '''Width of the axis aligned bounding rectangle where dragging is allowed.
+
+    :attr:`drag_rect_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 100.
+    '''
+
+    drag_rect_height = NumericProperty(100)
+    '''Height of the axis aligned bounding rectangle where dragging is allowed.
+
+    :attr:`drag_rect_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 100.
+    '''
+
+    drag_rectangle = ReferenceListProperty(drag_rect_x, drag_rect_y,
+                                           drag_rect_width, drag_rect_height)
+    '''Position and size of the axis aligned bounding rectangle where dragging
+    is allowed.
+
+    :attr:`drag_rectangle` is a :class:`~kivy.properties.ReferenceListProperty`
+    of (:attr:`drag_rect_x`, :attr:`drag_rect_y`, :attr:`drag_rect_width`,
+    :attr:`drag_rect_height`) properties.
+    '''
+
+    def __init__(self, **kwargs):
+        self._drag_touch = None
+        super(DragBehavior, self).__init__(**kwargs)
+
+    def _get_uid(self, prefix='sv'):
+        return '{0}.{1}'.format(prefix, self.uid)
+
+    def on_touch_down(self, touch):
+        xx, yy, w, h = self.drag_rectangle
+        x, y = touch.pos
+        if not self.collide_point(x, y):
+            touch.ud[self._get_uid('svavoid')] = True
+            return super(DragBehavior, self).on_touch_down(touch)
+        if self._drag_touch or ('button' in touch.profile and
+                                touch.button.startswith('scroll')) or\
+                not ((xx < x <= xx + w) and (yy < y <= yy + h)):
+            return super(DragBehavior, self).on_touch_down(touch)
+
+        # no mouse scrolling, so the user is going to drag with this touch.
+        self._drag_touch = touch
+        uid = self._get_uid()
+        touch.grab(self)
+        touch.ud[uid] = {
+            'mode': 'unknown',
+            'dx': 0,
+            'dy': 0}
+        Clock.schedule_once(self._change_touch_mode,
+                            self.drag_timeout / 1000.)
+        return True
+
+    def on_touch_move(self, touch):
+        if self._get_uid('svavoid') in touch.ud or\
+                self._drag_touch is not touch:
+            return super(DragBehavior, self).on_touch_move(touch) or\
+                self._get_uid() in touch.ud
+        if touch.grab_current is not self:
+            return True
+
+        uid = self._get_uid()
+        ud = touch.ud[uid]
+        mode = ud['mode']
+        if mode == 'unknown':
+            ud['dx'] += abs(touch.dx)
+            ud['dy'] += abs(touch.dy)
+            if ud['dx'] > sp(self.drag_distance):
+                mode = 'drag'
+            if ud['dy'] > sp(self.drag_distance):
+                mode = 'drag'
+            ud['mode'] = mode
+        if mode == 'drag':
+            self.x += touch.dx
+            self.y += touch.dy
+        return True
+
+    def on_touch_up(self, touch):
+        if self._get_uid('svavoid') in touch.ud:
+            return super(DragBehavior, self).on_touch_up(touch)
+
+        if self._drag_touch and self in [x() for x in touch.grab_list]:
+            touch.ungrab(self)
+            self._drag_touch = None
+            ud = touch.ud[self._get_uid()]
+            if ud['mode'] == 'unknown':
+                super(DragBehavior, self).on_touch_down(touch)
+                Clock.schedule_once(partial(self._do_touch_up, touch), .1)
+        else:
+            if self._drag_touch is not touch:
+                super(DragBehavior, self).on_touch_up(touch)
+        return self._get_uid() in touch.ud
+
+    def _do_touch_up(self, touch, *largs):
+        super(DragBehavior, self).on_touch_up(touch)
+        # don't forget about grab event!
+        for x in touch.grab_list[:]:
+            touch.grab_list.remove(x)
+            x = x()
+            if not x:
+                continue
+            touch.grab_current = x
+            super(DragBehavior, self).on_touch_up(touch)
+        touch.grab_current = None
+
+    def _change_touch_mode(self, *largs):
+        if not self._drag_touch:
+            return
+        uid = self._get_uid()
+        touch = self._drag_touch
+        ud = touch.ud[uid]
+        if ud['mode'] != 'unknown':
+            return
+        touch.ungrab(self)
+        self._drag_touch = None
+        touch.push()
+        touch.apply_transform_2d(self.parent.to_widget)
+        super(DragBehavior, self).on_touch_down(touch)
+        touch.pop()
+        return
diff --git a/kivy/uix/behaviors/emacs.py b/kivy/uix/behaviors/emacs.py
new file mode 100644
index 0000000..b4d3adb
--- /dev/null
+++ b/kivy/uix/behaviors/emacs.py
@@ -0,0 +1,140 @@
+# -*- encoding: utf-8 -*-
+'''
+Emacs Behavior
+==============
+
+The :class:`~kivy.uix.behaviors.emacs.EmacsBehavior`
+`mixin <https://en.wikipedia.org/wiki/Mixin>`_ allows you to add
+`Emacs <https://www.gnu.org/software/emacs/>`_ keyboard shortcuts for basic
+movement and editing to the :class:`~kivy.uix.textinput.TextInput` widget.
+The shortcuts currently available are listed below:
+
+Emacs shortcuts
+---------------
+=============== ========================================================
+   Shortcut     Description
+--------------- --------------------------------------------------------
+Control + a     Move cursor to the beginning of the line
+Control + e     Move cursor to the end of the line
+Control + f     Move cursor one character to the right
+Control + b     Move cursor one character to the left
+Alt + f         Move cursor to the end of the word to the right
+Alt + b         Move cursor to the start of the word to the left
+Alt + Backspace Delete text left of the cursor to the beginning of word
+Alt + d         Delete text right of the cursor to the end of the word
+Alt + w         Copy selection
+Control + w     Cut selection
+Control + y     Paste selection
+=============== ========================================================
+
+.. warning::
+    If you have the :mod:`~kivy.modules.inspector` module enabled, the
+    shortcut for opening the inspector (Control + e) conflicts with the
+    Emacs shortcut to move to the end of the line (it will still move the
+    cursor to the end of the line, but the inspector will open as well).
+'''
+
+from kivy.properties import StringProperty
+
+
+__all__ = ('EmacsBehavior', )
+
+
+class EmacsBehavior(object):
+    '''
+    A `mixin <https://en.wikipedia.org/wiki/Mixin>`_ that enables Emacs-style
+    keyboard shortcuts for the :class:`~kivy.uix.textinput.TextInput` widget.
+    Please see the :mod:`Emacs behaviors module <kivy.uix.behaviors.emacs>`
+    documentation for more information.
+
+    .. versionadded:: 1.9.1
+    '''
+
+    key_bindings = StringProperty('emacs')
+    '''String name which determines the type of key bindings to use with the
+    :class:`~kivy.uix.textinput.TextInput`. This allows Emacs key bindings to
+    be enabled/disabled programmatically for widgets that inherit from
+    :class:`EmacsBehavior`. If the value is not ``'emacs'``, Emacs bindings
+    will be disabled. Use ``'default'`` for switching to the default key
+    bindings of TextInput.
+
+    :attr:`key_bindings` is a :class:`~kivy.properties.StringProperty`
+    and defaults to ``'emacs'``.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    def __init__(self, **kwargs):
+        super(EmacsBehavior, self).__init__(**kwargs)
+
+        self.bindings = {
+            'ctrl': {
+                'a': lambda: self.do_cursor_movement('cursor_home'),
+                'e': lambda: self.do_cursor_movement('cursor_end'),
+                'f': lambda: self.do_cursor_movement('cursor_right'),
+                'b': lambda: self.do_cursor_movement('cursor_left'),
+                'w': lambda: self._cut(self.selection_text),
+                'y': self.paste,
+            },
+            'alt': {
+                'w': self.copy,
+                'f': lambda: self.do_cursor_movement('cursor_right',
+                                                     control=True),
+                'b': lambda: self.do_cursor_movement('cursor_left',
+                                                     control=True),
+                'd': self.delete_word_right,
+                '\x08': self.delete_word_left,  # alt + backspace
+            },
+        }
+
+    def keyboard_on_key_down(self, window, keycode, text, modifiers):
+
+        key, key_str = keycode
+
+        # join the modifiers e.g. ['alt', 'ctrl']
+        mod = '+'.join(modifiers) if modifiers else None
+        is_emacs_shortcut = False
+
+        if key in range(256) and self.key_bindings == 'emacs':
+            if mod == 'ctrl' and chr(key) in self.bindings['ctrl'].keys():
+                is_emacs_shortcut = True
+            elif mod == 'alt' and chr(key) in self.bindings['alt'].keys():
+                is_emacs_shortcut = True
+            else:  # e.g. ctrl+alt or alt+ctrl (alt-gr key)
+                is_emacs_shortcut = False
+
+        if is_emacs_shortcut:
+            # Look up mod and key
+            emacs_shortcut = self.bindings[mod][chr(key)]
+            emacs_shortcut()
+        else:
+            super(EmacsBehavior, self).keyboard_on_key_down(window, keycode,
+                                                            text, modifiers)
+
+    def delete_word_right(self):
+        '''Delete text right of the cursor to the end of the word'''
+        if self._selection:
+            return
+        start_index = self.cursor_index()
+        start_cursor = self.cursor
+        self.do_cursor_movement('cursor_right', control=True)
+        end_index = self.cursor_index()
+        if start_index != end_index:
+            s = self.text[start_index:end_index]
+            self._set_unredo_delsel(start_index, end_index, s, from_undo=False)
+            self.text = self.text[:start_index] + self.text[end_index:]
+            self._set_cursor(pos=start_cursor)
+
+    def delete_word_left(self):
+        '''Delete text left of the cursor to the beginning of word'''
+        if self._selection:
+            return
+        start_index = self.cursor_index()
+        self.do_cursor_movement('cursor_left', control=True)
+        end_cursor = self.cursor
+        end_index = self.cursor_index()
+        if start_index != end_index:
+            s = self.text[end_index:start_index]
+            self._set_unredo_delsel(end_index, start_index, s, from_undo=False)
+            self.text = self.text[:end_index] + self.text[start_index:]
+            self._set_cursor(pos=end_cursor)
diff --git a/kivy/uix/behaviors/focus.py b/kivy/uix/behaviors/focus.py
new file mode 100644
index 0000000..0295245
--- /dev/null
+++ b/kivy/uix/behaviors/focus.py
@@ -0,0 +1,587 @@
+'''
+Focus Behavior
+==============
+
+The :class:`~kivy.uix.behaviors.FocusBehavior`
+`mixin <https://en.wikipedia.org/wiki/Mixin>`_ class provides
+keyboard focus behavior. When combined with other
+FocusBehavior widgets it allows one to cycle focus among them by pressing
+tab. In addition, upon gaining focus, the instance will automatically
+receive keyboard input.
+
+Focus, very different from selection, is intimately tied with the keyboard;
+each keyboard can focus on zero or one widgets, and each widget can only
+have the focus of one keyboard. However, multiple keyboards can focus
+simultaneously on different widgets. When escape is hit, the widget having
+the focus of that keyboard will de-focus.
+
+Managing focus
+--------------
+
+In essence, focus is implemented as a doubly linked list, where each
+node holds a (weak) reference to the instance before it and after it,
+as visualized when cycling through the nodes using tab (forward) or
+shift+tab (backward). If a previous or next widget is not specified,
+:attr:`focus_next` and :attr:`focus_previous` defaults to `None`. This
+means that the :attr:`~kivy.uix.widget.Widget.children` list and
+:attr:`parents <kivy.uix.widget.Widget.parent>` are
+walked to find the next focusable widget, unless :attr:`focus_next` or
+:attr:`focus_previous` is set to the `StopIteration` class, in which case
+focus stops there.
+
+For example, to cycle focus between :class:`~kivy.uix.button.Button`
+elements of a :class:`~kivy.uix.gridlayout.GridLayout`::
+
+    class FocusButton(FocusBehavior, Button):
+      pass
+
+    grid = GridLayout(cols=4)
+    for i in range(40):
+        grid.add_widget(FocusButton(text=str(i)))
+    # clicking on a widget will activate focus, and tab can now be used
+    # to cycle through
+
+When using a software keyboard, typical on mobile and touch devices, the
+keyboard display behavior is determined by the
+:attr:`~kivy.core.window.WindowBase.softinput_mode` property. You can use
+this property to ensure the focused widget is not covered or obscured by the
+keyboard.
+
+Initializing focus
+------------------
+
+Widgets needs to be visible before they can receive the focus. This means that
+setting their *focus* property to True before they are visible will have no
+effect. To initialize focus, you can use the 'on_parent' event::
+
+    from kivy.app import App
+    from kivy.uix.textinput import TextInput
+
+    class MyTextInput(TextInput):
+        def on_parent(self, widget, parent):
+            self.focus = True
+
+    class SampleApp(App):
+        def build(self):
+            return MyTextInput()
+
+    SampleApp().run()
+
+If you are using a :class:`~kivy.uix.popup`, you can use the 'on_open' event.
+
+For an overview of behaviors, please refer to the :mod:`~kivy.uix.behaviors`
+documentation.
+
+.. warning::
+
+    This code is still experimental, and its API is subject to change in a
+    future version.
+'''
+
+__all__ = ('FocusBehavior', )
+
+from kivy.properties import OptionProperty, ObjectProperty, BooleanProperty, \
+    AliasProperty
+from kivy.config import Config
+from kivy.base import EventLoop
+
+# When we are generating documentation, Config doesn't exist
+_is_desktop = False
+_keyboard_mode = 'system'
+if Config:
+    _is_desktop = Config.getboolean('kivy', 'desktop')
+    _keyboard_mode = Config.get('kivy', 'keyboard_mode')
+
+
+class FocusBehavior(object):
+    '''Provides keyboard focus behavior. When combined with other
+    FocusBehavior widgets it allows one to cycle focus among them by pressing
+    tab. Please see the
+    :mod:`focus behavior module documentation <kivy.uix.behaviors.focus>`
+    for more information.
+
+    .. versionadded:: 1.9.0
+
+    '''
+
+    _requested_keyboard = False
+    _keyboard = ObjectProperty(None, allownone=True)
+    _keyboards = {}
+
+    ignored_touch = []
+    '''A list of touches that should not be used to defocus. After on_touch_up,
+    every touch that is not in :attr:`ignored_touch` will defocus all the
+    focused widgets if the config keyboard mode is not multi. Touches on
+    focusable widgets that were used to focus are automatically added here.
+
+    Example usage::
+
+        class Unfocusable(Widget):
+
+            def on_touch_down(self, touch):
+                if self.collide_point(*touch.pos):
+                    FocusBehavior.ignored_touch.append(touch)
+
+    Notice that you need to access this as a class, not an instance variable.
+    '''
+
+    def _set_keyboard(self, value):
+        focus = self.focus
+        keyboard = self._keyboard
+        keyboards = FocusBehavior._keyboards
+        if keyboard:
+            self.focus = False    # this'll unbind
+            if self._keyboard:  # remove assigned keyboard from dict
+                del keyboards[keyboard]
+        if value and value not in keyboards:
+            keyboards[value] = None
+        self._keyboard = value
+        self.focus = focus
+
+    def _get_keyboard(self):
+        return self._keyboard
+    keyboard = AliasProperty(_get_keyboard, _set_keyboard,
+                             bind=('_keyboard', ))
+    '''The keyboard to bind to (or bound to the widget) when focused.
+
+    When None, a keyboard is requested and released whenever the widget comes
+    into and out of focus. If not None, it must be a keyboard, which gets
+    bound and unbound from the widget whenever it's in or out of focus. It is
+    useful only when more than one keyboard is available, so it is recommended
+    to be set to None when only one keyboard is available.
+
+    If more than one keyboard is available, whenever an instance gets focused
+    a new keyboard will be requested if None. Unless the other instances lose
+    focus (e.g. if tab was used), a new keyboard will appear. When this is
+    undesired, the keyboard property can be used. For example, if there are
+    two users with two keyboards, then each keyboard can be assigned to
+    different groups of instances of FocusBehavior, ensuring that within
+    each group, only one FocusBehavior will have focus, and will receive input
+    from the correct keyboard. See `keyboard_mode` in :mod:`~kivy.config` for
+    more information on the keyboard modes.
+
+    **Keyboard and focus behavior**
+
+    When using the keyboard, there are some important default behaviors you
+    should keep in mind.
+
+    * When Config's `keyboard_mode` is multi, each new touch is considered
+      a touch by a different user and will set the focus (if clicked on a
+      focusable) with a new keyboard. Already focused elements will not lose
+      their focus (even if an unfocusable widget is touched).
+
+    * If the keyboard property is set, that keyboard will be used when the
+      instance gets focused. If widgets with different keyboards are linked
+      through :attr:`focus_next` and :attr:`focus_previous`, then as they are
+      tabbed through, different keyboards will become active. Therefore,
+      typically it's undesirable to link instances which are assigned
+      different keyboards.
+
+    * When a widget has focus, setting its keyboard to None will remove its
+      keyboard, but the widget will then immediately try to get
+      another keyboard. In order to remove its keyboard, rather set its
+      :attr:`focus` to False.
+
+    * When using a software keyboard, typical on mobile and touch devices, the
+      keyboard display behavior is determined by the
+      :attr:`~kivy.core.window.WindowBase.softinput_mode` property. You can use
+      this property to ensure the focused widget is not covered or obscured.
+
+    :attr:`keyboard` is an :class:`~kivy.properties.AliasProperty` and defaults
+    to None.
+
+    .. warning:
+
+        When assigning a keyboard, the keyboard must not be released while
+        it is still assigned to an instance. Similarly, the keyboard created
+        by the instance on focus and assigned to :attr:`keyboard` if None,
+        will be released by the instance when the instance loses focus.
+        Therefore, it is not safe to assign this keyboard to another instance's
+        :attr:`keyboard`.
+    '''
+
+    is_focusable = BooleanProperty(_is_desktop)
+    '''Whether the instance can become focused. If focused, it'll lose focus
+    when set to False.
+
+    :attr:`is_focusable` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True on a desktop (i.e. `desktop` is True in
+    :mod:`~kivy.config`), False otherwise.
+    '''
+
+    focus = BooleanProperty(False)
+    '''Whether the instance currently has focus.
+
+    Setting it to True will bind to and/or request the keyboard, and input
+    will be forwarded to the instance. Setting it to False will unbind
+    and/or release the keyboard. For a given keyboard, only one widget can
+    have its focus, so focusing one will automatically unfocus the other
+    instance holding its focus.
+
+    When using a software keyboard, please refer to the
+    :attr:`~kivy.core.window.WindowBase.softinput_mode` property to determine
+    how the keyboard display is handled.
+
+    :attr:`focus` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    focused = focus
+    '''An alias of :attr:`focus`.
+
+    :attr:`focused` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+
+    .. warning::
+        :attr:`focused` is an alias of :attr:`focus` and will be removed in
+        2.0.0.
+    '''
+
+    keyboard_suggestions = BooleanProperty(True)
+    '''If True provides auto suggestions on top of keyboard.
+    This will only work if :attr:`input_type` is set to `text`, `url`, `mail` or
+    `address`.
+
+    .. versionadded:: 2.1.0
+
+    :attr:`keyboard_suggestions` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True
+    '''
+
+    def _set_on_focus_next(self, instance, value):
+        ''' If changing code, ensure following code is not infinite loop:
+        widget.focus_next = widget
+        widget.focus_previous = widget
+        widget.focus_previous = widget2
+        '''
+        next = self._old_focus_next
+        if next is value:   # prevent infinite loop
+            return
+
+        if isinstance(next, FocusBehavior):
+            next.focus_previous = None
+        self._old_focus_next = value
+        if value is None or value is StopIteration:
+            return
+        if not isinstance(value, FocusBehavior):
+            raise ValueError('focus_next accepts only objects based on'
+                             ' FocusBehavior, or the `StopIteration` class.')
+        value.focus_previous = self
+
+    focus_next = ObjectProperty(None, allownone=True)
+    '''The :class:`FocusBehavior` instance to acquire focus when
+    tab is pressed and this instance has focus, if not `None` or
+    `StopIteration`.
+
+    When tab is pressed, focus cycles through all the :class:`FocusBehavior`
+    widgets that are linked through :attr:`focus_next` and are focusable. If
+    :attr:`focus_next` is `None`, it instead walks the children lists to find
+    the next focusable widget. Finally, if :attr:`focus_next` is
+    the `StopIteration` class, focus won't move forward, but end here.
+
+    .. note:
+
+        Setting :attr:`focus_next` automatically sets :attr:`focus_previous`
+        of the other instance to point to this instance, if not None or
+        `StopIteration`. Similarly, if it wasn't None or `StopIteration`, it
+        also sets the :attr:`focus_previous` property of the instance
+        previously in :attr:`focus_next` to `None`. Therefore, it is only
+        required to set one of the :attr:`focus_previous` or
+        :attr:`focus_next` links since the other side will be set
+        automatically.
+
+    :attr:`focus_next` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to `None`.
+    '''
+
+    def _set_on_focus_previous(self, instance, value):
+        prev = self._old_focus_previous
+        if prev is value:
+            return
+
+        if isinstance(prev, FocusBehavior):
+            prev.focus_next = None
+        self._old_focus_previous = value
+        if value is None or value is StopIteration:
+            return
+        if not isinstance(value, FocusBehavior):
+            raise ValueError('focus_previous accepts only objects based'
+                             'on FocusBehavior, or the `StopIteration` class.')
+        value.focus_next = self
+
+    focus_previous = ObjectProperty(None, allownone=True)
+    '''The :class:`FocusBehavior` instance to acquire focus when
+    shift+tab is pressed on this instance, if not None or `StopIteration`.
+
+    When shift+tab is pressed, focus cycles through all the
+    :class:`FocusBehavior` widgets that are linked through
+    :attr:`focus_previous` and are focusable. If :attr:`focus_previous` is
+    `None`, it instead walks the children tree to find the
+    previous focusable widget. Finally, if :attr:`focus_previous` is the
+    `StopIteration` class, focus won't move backward, but end here.
+
+    .. note:
+
+        Setting :attr:`focus_previous` automatically sets :attr:`focus_next`
+        of the other instance to point to this instance, if not None or
+        `StopIteration`. Similarly, if it wasn't None or `StopIteration`, it
+        also sets the :attr:`focus_next` property of the instance previously in
+        :attr:`focus_previous` to `None`. Therefore, it is only required
+        to set one of the :attr:`focus_previous` or :attr:`focus_next`
+        links since the other side will be set automatically.
+
+    :attr:`focus_previous` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to `None`.
+    '''
+
+    keyboard_mode = OptionProperty('auto', options=('auto', 'managed'))
+    '''Determines how the keyboard visibility should be managed. 'auto' will
+    result in the standard behaviour of showing/hiding on focus. 'managed'
+    requires setting the keyboard visibility manually, or calling the helper
+    functions :meth:`show_keyboard` and :meth:`hide_keyboard`.
+
+    :attr:`keyboard_mode` is an :class:`~kivy.properties.OptionsProperty` and
+    defaults to 'auto'. Can be one of 'auto' or 'managed'.
+    '''
+
+    input_type = OptionProperty('null', options=('null', 'text', 'number',
+                                                 'url', 'mail', 'datetime',
+                                                 'tel', 'address'))
+    '''The kind of input keyboard to request.
+
+    .. versionadded:: 1.8.0
+
+    .. versionchanged:: 2.1.0
+        Changed default value from `text` to `null`. Added `null` to options.
+
+        .. warning::
+            As the default value has been changed, you may need to adjust
+            `input_type` in your code.
+
+    :attr:`input_type` is an :class:`~kivy.properties.OptionsProperty` and
+    defaults to 'null'. Can be one of 'null', 'text', 'number', 'url', 'mail',
+    'datetime', 'tel' or 'address'.
+    '''
+
+    unfocus_on_touch = BooleanProperty(_keyboard_mode not in
+                                       ('multi', 'systemandmulti'))
+    '''Whether a instance should lose focus when clicked outside the instance.
+
+    When a user clicks on a widget that is focus aware and shares the same
+    keyboard as this widget (which in the case of only one keyboard, are
+    all focus aware widgets), then as the other widgets gains focus, this
+    widget loses focus. In addition to that, if this property is `True`,
+    clicking on any widget other than this widget, will remove focus form this
+    widget.
+
+    :attr:`unfocus_on_touch` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to `False` if the `keyboard_mode` in :attr:`~kivy.config.Config`
+    is `'multi'` or `'systemandmulti'`, otherwise it defaults to `True`.
+    '''
+
+    def __init__(self, **kwargs):
+        self._old_focus_next = None
+        self._old_focus_previous = None
+        super(FocusBehavior, self).__init__(**kwargs)
+
+        self._keyboard_mode = _keyboard_mode
+        fbind = self.fbind
+        fbind('focus', self._on_focus)
+        fbind('disabled', self._on_focusable)
+        fbind('is_focusable', self._on_focusable)
+        fbind('focus_next', self._set_on_focus_next)
+        fbind('focus_previous', self._set_on_focus_previous)
+
+    def _on_focusable(self, instance, value):
+        if self.disabled or not self.is_focusable:
+            self.focus = False
+
+    def _on_focus(self, instance, value, *largs):
+        if self.keyboard_mode == 'auto':
+            if value:
+                self._bind_keyboard()
+            else:
+                self._unbind_keyboard()
+
+    def _ensure_keyboard(self):
+        if self._keyboard is None:
+            self._requested_keyboard = True
+            keyboard = self._keyboard = EventLoop.window.request_keyboard(
+                self._keyboard_released,
+                self,
+                input_type=self.input_type,
+                keyboard_suggestions=self.keyboard_suggestions,
+            )
+            keyboards = FocusBehavior._keyboards
+            if keyboard not in keyboards:
+                keyboards[keyboard] = None
+
+    def _bind_keyboard(self):
+        self._ensure_keyboard()
+        keyboard = self._keyboard
+
+        if not keyboard or self.disabled or not self.is_focusable:
+            self.focus = False
+            return
+        keyboards = FocusBehavior._keyboards
+        old_focus = keyboards[keyboard]  # keyboard should be in dict
+        if old_focus:
+            old_focus.focus = False
+            # keyboard shouldn't have been released here, see keyboard warning
+        keyboards[keyboard] = self
+        keyboard.bind(on_key_down=self.keyboard_on_key_down,
+                      on_key_up=self.keyboard_on_key_up,
+                      on_textinput=self.keyboard_on_textinput)
+
+    def _unbind_keyboard(self):
+        keyboard = self._keyboard
+        if keyboard:
+            keyboard.unbind(on_key_down=self.keyboard_on_key_down,
+                            on_key_up=self.keyboard_on_key_up,
+                            on_textinput=self.keyboard_on_textinput)
+            if self._requested_keyboard:
+                keyboard.release()
+                self._keyboard = None
+                self._requested_keyboard = False
+                del FocusBehavior._keyboards[keyboard]
+            else:
+                FocusBehavior._keyboards[keyboard] = None
+
+    def keyboard_on_textinput(self, window, text):
+        pass
+
+    def _keyboard_released(self):
+        self.focus = False
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return
+        if (not self.disabled and self.is_focusable and
+            ('button' not in touch.profile or
+             not touch.button.startswith('scroll'))):
+            self.focus = True
+            FocusBehavior.ignored_touch.append(touch)
+        return super(FocusBehavior, self).on_touch_down(touch)
+
+    @staticmethod
+    def _handle_post_on_touch_up(touch):
+        ''' Called by window after each touch has finished.
+        '''
+        touches = FocusBehavior.ignored_touch
+        if touch in touches:
+            touches.remove(touch)
+            return
+        if 'button' in touch.profile and touch.button in\
+                ('scrollup', 'scrolldown', 'scrollleft', 'scrollright'):
+            return
+        for focusable in list(FocusBehavior._keyboards.values()):
+            if focusable is None or not focusable.unfocus_on_touch:
+                continue
+            focusable.focus = False
+
+    def _get_focus_next(self, focus_dir):
+        current = self
+        walk_tree = 'walk' if focus_dir == 'focus_next' else 'walk_reverse'
+
+        while 1:
+            # if we hit a focusable, walk through focus_xxx
+            while getattr(current, focus_dir) is not None:
+                current = getattr(current, focus_dir)
+                if current is self or current is StopIteration:
+                    return None  # make sure we don't loop forever
+                if current.is_focusable and not current.disabled:
+                    return current
+
+            # hit unfocusable, walk widget tree
+            itr = getattr(current, walk_tree)(loopback=True)
+            if focus_dir == 'focus_next':
+                next(itr)  # current is returned first  when walking forward
+            for current in itr:
+                if isinstance(current, FocusBehavior):
+                    break
+            # why did we stop
+            if isinstance(current, FocusBehavior):
+                if current is self:
+                    return None
+                if current.is_focusable and not current.disabled:
+                    return current
+            else:
+                return None
+
+    def get_focus_next(self):
+        '''Returns the next focusable widget using either :attr:`focus_next`
+           or the :attr:`children` similar to the order when tabbing forwards
+           with the ``tab`` key.
+        '''
+        return self._get_focus_next('focus_next')
+
+    def get_focus_previous(self):
+        '''Returns the previous focusable widget using either
+           :attr:`focus_previous` or the :attr:`children` similar to the
+           order when ``tab`` + ``shift`` key are triggered together.
+        '''
+        return self._get_focus_next('focus_previous')
+
+    def keyboard_on_key_down(self, window, keycode, text, modifiers):
+        '''The method bound to the keyboard when the instance has focus.
+
+        When the instance becomes focused, this method is bound to the
+        keyboard and will be called for every input press. The parameters are
+        the same as :meth:`kivy.core.window.WindowBase.on_key_down`.
+
+        When overwriting the method in the derived widget, super should be
+        called to enable tab cycling. If the derived widget wishes to use tab
+        for its own purposes, it can call super after it has processed the
+        character (if it does not wish to consume the tab).
+
+        Similar to other keyboard functions, it should return True if the
+        key was consumed.
+        '''
+        if keycode[1] == 'tab':  # deal with cycle
+            modifiers = set(modifiers)
+            if {'ctrl', 'alt', 'meta', 'super', 'compose'} & modifiers:
+                return False
+            if 'shift' in modifiers:
+                next = self.get_focus_previous()
+            else:
+                next = self.get_focus_next()
+            if next:
+                self.focus = False
+
+                next.focus = True
+
+            return True
+        return False
+
+    def keyboard_on_key_up(self, window, keycode):
+        '''The method bound to the keyboard when the instance has focus.
+
+        When the instance becomes focused, this method is bound to the
+        keyboard and will be called for every input release. The parameters are
+        the same as :meth:`kivy.core.window.WindowBase.on_key_up`.
+
+        When overwriting the method in the derived widget, super should be
+        called to enable de-focusing on escape. If the derived widget wishes
+        to use escape for its own purposes, it can call super after it has
+        processed the character (if it does not wish to consume the escape).
+
+        See :meth:`keyboard_on_key_down`
+        '''
+        if keycode[1] == 'escape':
+            self.focus = False
+            return True
+        return False
+
+    def show_keyboard(self):
+        '''
+        Convenience function to show the keyboard in managed mode.
+        '''
+        if self.keyboard_mode == 'managed':
+            self._bind_keyboard()
+
+    def hide_keyboard(self):
+        '''
+        Convenience function to hide the keyboard in managed mode.
+        '''
+        if self.keyboard_mode == 'managed':
+            self._unbind_keyboard()
diff --git a/kivy/uix/behaviors/knspace.py b/kivy/uix/behaviors/knspace.py
new file mode 100644
index 0000000..2c19b32
--- /dev/null
+++ b/kivy/uix/behaviors/knspace.py
@@ -0,0 +1,590 @@
+'''
+Kivy Namespaces
+===============
+
+.. versionadded:: 1.9.1
+
+.. warning::
+    This code is still experimental, and its API is subject to change in a
+    future version.
+
+The :class:`KNSpaceBehavior` `mixin <https://en.wikipedia.org/wiki/Mixin>`_
+class provides namespace functionality for Kivy objects. It allows kivy objects
+to be named and then accessed using namespaces.
+
+:class:`KNSpace` instances are the namespaces that store the named objects
+in Kivy :class:`~kivy.properties.ObjectProperty` instances.
+In addition, when inheriting from :class:`KNSpaceBehavior`, if the derived
+object is named, the name will automatically be added to the associated
+namespace and will point to a :attr:`~kivy.uix.widget.proxy_ref` of the
+derived object.
+
+Basic examples
+--------------
+
+By default, there's only a single namespace: the :attr:`knspace` namespace. The
+simplest example is adding a widget to the namespace:
+
+.. code-block:: python
+
+    from kivy.uix.behaviors.knspace import knspace
+    widget = Widget()
+    knspace.my_widget = widget
+
+This adds a kivy :class:`~kivy.properties.ObjectProperty` with `rebind=True`
+and `allownone=True` to the :attr:`knspace` namespace with a property name
+`my_widget`. And the property now also points to this widget.
+
+This can be done automatically with:
+
+.. code-block:: python
+
+    class MyWidget(KNSpaceBehavior, Widget):
+        pass
+
+    widget = MyWidget(knsname='my_widget')
+
+Or in kv:
+
+.. code-block:: kv
+
+    <MyWidget@KNSpaceBehavior+Widget>
+
+    MyWidget:
+        knsname: 'my_widget'
+
+Now, `knspace.my_widget` will point to that widget.
+
+When one creates a second widget with the same name, the namespace will
+also change to point to the new widget. E.g.:
+
+.. code-block:: python
+
+    widget = MyWidget(knsname='my_widget')
+    # knspace.my_widget now points to widget
+    widget2 = MyWidget(knsname='my_widget')
+    # knspace.my_widget now points to widget2
+
+Setting the namespace
+---------------------
+
+One can also create ones own namespace rather than using the default
+:attr:`knspace` by directly setting :attr:`KNSpaceBehavior.knspace`:
+
+.. code-block:: python
+
+    class MyWidget(KNSpaceBehavior, Widget):
+        pass
+
+    widget = MyWidget(knsname='my_widget')
+    my_new_namespace = KNSpace()
+    widget.knspace = my_new_namespace
+
+Initially, `my_widget` is added to the default namespace, but when the widget's
+namespace is changed to `my_new_namespace`, the reference to `my_widget` is
+moved to that namespace. We could have also of course first set the namespace
+to `my_new_namespace` and then have named the widget `my_widget`, thereby
+avoiding the initial assignment to the default namespace.
+
+Similarly, in kv:
+
+.. code-block:: kv
+
+    <MyWidget@KNSpaceBehavior+Widget>
+
+    MyWidget:
+        knspace: KNSpace()
+        knsname: 'my_widget'
+
+Inheriting the namespace
+------------------------
+
+In the previous example, we directly set the namespace we wished to use.
+In the following example, we inherit it from the parent, so we only have to set
+it once:
+
+.. code-block:: kv
+
+    <MyWidget@KNSpaceBehavior+Widget>
+    <MyLabel@KNSpaceBehavior+Label>
+
+    <MyComplexWidget@MyWidget>:
+        knsname: 'my_complex'
+        MyLabel:
+            knsname: 'label1'
+        MyLabel:
+            knsname: 'label2'
+
+Then, we do:
+
+.. code-block:: python
+
+    widget = MyComplexWidget()
+    new_knspace = KNSpace()
+    widget.knspace = new_knspace
+
+The rule is that if no knspace has been assigned to a widget, it looks for a
+namespace in its parent and parent's parent and so on until it find one to
+use. If none are found, it uses the default :attr:`knspace`.
+
+When `MyComplexWidget` is created, it still used the default namespace.
+However, when we assigned the root widget its new namespace, all its
+children switched to using that new namespace as well. So `new_knspace` now
+contains `label1` and `label2` as well as `my_complex`.
+
+If we had first done:
+
+.. code-block:: python
+
+    widget = MyComplexWidget()
+    new_knspace = KNSpace()
+    knspace.label1.knspace = knspace
+    widget.knspace = new_knspace
+
+Then `label1` would remain stored in the default :attr:`knspace` since it was
+directly set, but `label2` and `my_complex` would still be added to the new
+namespace.
+
+One can customize the attribute used to search the parent tree by changing
+:attr:`KNSpaceBehavior.knspace_key`. If the desired knspace is not reachable
+through a widgets parent tree, e.g. in a popup that is not a widget's child,
+:attr:`KNSpaceBehavior.knspace_key` can be used to establish a different
+search order.
+
+Accessing the namespace
+-----------------------
+
+As seen in the previous example, if not directly assigned, the namespace is
+found by searching the parent tree. Consequently, if a namespace was assigned
+further up the parent tree, all its children and below could access that
+namespace through their :attr:`KNSpaceBehavior.knspace` property.
+
+This allows the creation of multiple widgets with identically given names
+if each root widget instance is assigned a new namespace. For example:
+
+.. code-block:: kv
+
+    <MyComplexWidget@KNSpaceBehavior+Widget>:
+        Label:
+            text: root.knspace.pretty.text if root.knspace.pretty else ''
+
+    <MyPrettyWidget@KNSpaceBehavior+TextInput>:
+        knsname: 'pretty'
+        text: 'Hello'
+
+    <MyCompositeWidget@KNSpaceBehavior+BoxLayout>:
+        MyComplexWidget
+        MyPrettyWidget
+
+Now, when we do:
+
+.. code-block:: python
+
+    knspace1, knspace2 = KNSpace(), KNSpace()
+    composite1 = MyCompositeWidget()
+    composite1.knspace = knspace1
+
+    composite2 = MyCompositeWidget()
+    composite2.knspace = knspace2
+
+    knspace1.pretty = "Here's the ladder, now fix the roof!"
+    knspace2.pretty = "Get that raccoon off me!"
+
+Because each of the `MyCompositeWidget` instances have a different namespace
+their children also use different namespaces. Consequently, the
+pretty and complex widgets of each instance will have different text.
+
+Further, because both the namespace :class:`~kivy.properties.ObjectProperty`
+references, and :attr:`KNSpaceBehavior.knspace` have `rebind=True`, the
+text of the `MyComplexWidget` label is rebound to match the text of
+`MyPrettyWidget` when either the root's namespace changes or when the
+`root.knspace.pretty` property changes, as expected.
+
+Forking a namespace
+-------------------
+
+Forking a namespace provides the opportunity to create a new namespace
+from a parent namespace so that the forked namespace will contain everything
+in the origin namespace, but the origin namespace will not have access to
+anything added to the forked namespace.
+
+For example:
+
+.. code-block:: python
+
+    child = knspace.fork()
+    grandchild = child.fork()
+
+    child.label = Label()
+    grandchild.button = Button()
+
+Now label is accessible by both child and grandchild, but not by knspace. And
+button is only accessible by the grandchild but not by the child or by knspace.
+Finally, doing `grandchild.label = Label()` will leave `grandchild.label`
+and `child.label` pointing to different labels.
+
+A motivating example is the example from above:
+
+.. code-block:: kv
+
+    <MyComplexWidget@KNSpaceBehavior+Widget>:
+        Label:
+            text: root.knspace.pretty.text if root.knspace.pretty else ''
+
+    <MyPrettyWidget@KNSpaceBehavior+TextInput>:
+        knsname: 'pretty'
+        text: 'Hello'
+
+    <MyCompositeWidget@KNSpaceBehavior+BoxLayout>:
+        knspace: 'fork'
+        MyComplexWidget
+        MyPrettyWidget
+
+Notice the addition of `knspace: 'fork'`. This is identical to doing
+`knspace: self.knspace.fork()`. However, doing that would lead to infinite
+recursion as that kv rule would be executed recursively because `self.knspace`
+will keep on changing. However, allowing `knspace: 'fork'` cirumvents that.
+See :attr:`KNSpaceBehavior.knspace`.
+
+Now, having forked, we just need to do:
+
+.. code-block:: python
+
+    composite1 = MyCompositeWidget()
+    composite2 = MyCompositeWidget()
+
+    composite1.knspace.pretty = "Here's the ladder, now fix the roof!"
+    composite2.knspace.pretty = "Get that raccoon off me!"
+
+Since by forking we automatically created a unique namespace for each
+`MyCompositeWidget` instance.
+'''
+
+__all__ = ('KNSpace', 'KNSpaceBehavior', 'knspace')
+
+from kivy.event import EventDispatcher
+from kivy.properties import StringProperty, ObjectProperty, AliasProperty
+from kivy.context import register_context
+
+
+class KNSpace(EventDispatcher):
+    '''Each :class:`KNSpace` instance is a namespace that stores the named Kivy
+    objects associated with this namespace. Each named object is
+    stored as the value of a Kivy :class:`~kivy.properties.ObjectProperty` of
+    this instance whose property name is the object's given name. Both `rebind`
+    and `allownone` are set to `True` for the property.
+
+    See :attr:`KNSpaceBehavior.knspace` for details on how a namespace is
+    associated with a named object.
+
+    When storing an object in the namespace, the object's `proxy_ref` is
+    stored if the object has such an attribute.
+
+    :Parameters:
+
+        `parent`: (internal) A :class:`KNSpace` instance or None.
+            If specified, it's a parent namespace, in which case, the current
+            namespace will have in its namespace all its named objects
+            as well as the named objects of its parent and parent's parent
+            etc. See :meth:`fork` for more details.
+    '''
+
+    parent = None
+    '''(internal) The parent namespace instance, :class:`KNSpace`, or None. See
+    :meth:`fork`.
+    '''
+    __has_applied = None
+
+    keep_ref = False
+    '''Whether a direct reference should be kept to the stored objects.
+    If ``True``, we use the direct object, otherwise we use
+    :attr:`~kivy.uix.widget.proxy_ref` when present.
+
+    Defaults to False.
+    '''
+
+    def __init__(self, parent=None, keep_ref=False, **kwargs):
+        self.keep_ref = keep_ref
+        super(KNSpace, self).__init__(**kwargs)
+        self.parent = parent
+        self.__has_applied = set(self.properties().keys())
+
+    def __setattr__(self, name, value):
+        prop = super(KNSpace, self).property(name, quiet=True)
+        has_applied = self.__has_applied
+        if prop is None:
+            if hasattr(self, name):
+                super(KNSpace, self).__setattr__(name, value)
+            else:
+                self.apply_property(
+                    **{name:
+                       ObjectProperty(None, rebind=True, allownone=True)}
+                )
+                if not self.keep_ref:
+                    value = getattr(value, 'proxy_ref', value)
+                has_applied.add(name)
+                super(KNSpace, self).__setattr__(name, value)
+        elif name not in has_applied:
+            self.apply_property(**{name: prop})
+            has_applied.add(name)
+            if not self.keep_ref:
+                value = getattr(value, 'proxy_ref', value)
+            super(KNSpace, self).__setattr__(name, value)
+        else:
+            if not self.keep_ref:
+                value = getattr(value, 'proxy_ref', value)
+            super(KNSpace, self).__setattr__(name, value)
+
+    def __getattribute__(self, name):
+        if name in super(KNSpace, self).__getattribute__('__dict__'):
+            return super(KNSpace, self).__getattribute__(name)
+
+        try:
+            value = super(KNSpace, self).__getattribute__(name)
+        except AttributeError:
+            parent = super(KNSpace, self).__getattribute__('parent')
+            if parent is None:
+                raise AttributeError(name)
+            return getattr(parent, name)
+
+        if value is not None:
+            return value
+
+        parent = super(KNSpace, self).__getattribute__('parent')
+        if parent is None:
+            return None
+
+        try:
+            return getattr(parent, name)  # if parent doesn't have it
+        except AttributeError:
+            return None
+
+    def property(self, name, quiet=False):
+        # needs to overwrite EventDispatcher.property so kv lang will work
+        prop = super(KNSpace, self).property(name, quiet=True)
+        if prop is not None:
+            return prop
+
+        prop = ObjectProperty(None, rebind=True, allownone=True)
+        self.apply_property(**{name: prop})
+        self.__has_applied.add(name)
+        return prop
+
+    def fork(self):
+        '''Returns a new :class:`KNSpace` instance which will have access to
+        all the named objects in the current namespace but will also have a
+        namespace of its own that is unique to it.
+
+        For example:
+
+        .. code-block:: python
+
+            forked_knspace1 = knspace.fork()
+            forked_knspace2 = knspace.fork()
+
+        Now, any names added to `knspace` will be accessible by the
+        `forked_knspace1` and `forked_knspace2` namespaces by the normal means.
+        However, any names added to `forked_knspace1` will not be accessible
+        from `knspace` or `forked_knspace2`. Similar for `forked_knspace2`.
+        '''
+        return KNSpace(parent=self)
+
+
+class KNSpaceBehavior(object):
+    '''Inheriting from this class allows naming of the inherited objects, which
+    are then added to the associated namespace :attr:`knspace` and accessible
+    through it.
+
+    Please see the :mod:`knspace behaviors module <kivy.uix.behaviors.knspace>`
+    documentation for more information.
+    '''
+
+    _knspace = ObjectProperty(None, allownone=True)
+    _knsname = StringProperty('')
+    __last_knspace = None
+    __callbacks = None
+
+    def __init__(self, knspace=None, **kwargs):
+        self.knspace = knspace
+        super(KNSpaceBehavior, self).__init__(**kwargs)
+
+    def __knspace_clear_callbacks(self, *largs):
+        for obj, name, uid in self.__callbacks:
+            obj.unbind_uid(name, uid)
+        last = self.__last_knspace
+        self.__last_knspace = self.__callbacks = None
+
+        assert self._knspace is None
+        assert last
+
+        new = self.__set_parent_knspace()
+        if new is last:
+            return
+        self.property('_knspace').dispatch(self)
+
+        name = self.knsname
+        if not name:
+            return
+
+        if getattr(last, name) == self:
+            setattr(last, name, None)
+
+        if new:
+            setattr(new, name, self)
+        else:
+            raise ValueError('Object has name "{}", but no namespace'.
+                             format(name))
+
+    def __set_parent_knspace(self):
+        callbacks = self.__callbacks = []
+        fbind = self.fbind
+        append = callbacks.append
+        parent_key = self.knspace_key
+        clear = self.__knspace_clear_callbacks
+
+        append((self, 'knspace_key', fbind('knspace_key', clear)))
+        if not parent_key:
+            self.__last_knspace = knspace
+            return knspace
+
+        append((self, parent_key, fbind(parent_key, clear)))
+        parent = getattr(self, parent_key, None)
+        while parent is not None:
+            fbind = parent.fbind
+
+            parent_knspace = getattr(parent, 'knspace', 0)
+            if parent_knspace != 0:
+                append((parent, 'knspace', fbind('knspace', clear)))
+                self.__last_knspace = parent_knspace
+                return parent_knspace
+
+            append((parent, parent_key, fbind(parent_key, clear)))
+            new_parent = getattr(parent, parent_key, None)
+            if new_parent is parent:
+                break
+            parent = new_parent
+        self.__last_knspace = knspace
+        return knspace
+
+    def _get_knspace(self):
+        _knspace = self._knspace
+        if _knspace is not None:
+            return _knspace
+
+        if self.__callbacks is not None:
+            return self.__last_knspace
+
+        # we only get here if we never accessed our knspace
+        return self.__set_parent_knspace()
+
+    def _set_knspace(self, value):
+        if value is self._knspace:
+            return
+
+        knspace = self._knspace or self.__last_knspace
+        name = self.knsname
+        if name and knspace and getattr(knspace, name) == self:
+            setattr(knspace, name, None)  # reset old namespace
+
+        if value == 'fork':
+            if not knspace:
+                knspace = self.knspace  # get parents in case we haven't before
+            if knspace:
+                value = knspace.fork()
+            else:
+                raise ValueError('Cannot fork with no namespace')
+
+        for obj, prop_name, uid in self.__callbacks or []:
+            obj.unbind_uid(prop_name, uid)
+        self.__last_knspace = self.__callbacks = None
+
+        if name:
+            if value is None:  # if None, first update the recursive knspace
+                knspace = self.__set_parent_knspace()
+                if knspace:
+                    setattr(knspace, name, self)
+                self._knspace = None  # cause a kv trigger
+            else:
+                setattr(value, name, self)
+                knspace = self._knspace = value
+
+            if not knspace:
+                raise ValueError('Object has name "{}", but no namespace'.
+                                 format(name))
+        else:
+            if value is None:
+                self.__set_parent_knspace()  # update before trigger below
+            self._knspace = value
+
+    knspace = AliasProperty(
+        _get_knspace, _set_knspace, bind=('_knspace', ), cache=False,
+        rebind=True, allownone=True)
+    '''The namespace instance, :class:`KNSpace`, associated with this widget.
+    The :attr:`knspace` namespace stores this widget when naming this widget
+    with :attr:`knsname`.
+
+    If the namespace has been set with a :class:`KNSpace` instance, e.g. with
+    `self.knspace = KNSpace()`, then that instance is returned (setting with
+    `None` doesn't count). Otherwise, if :attr:`knspace_key` is not None, we
+    look for a namespace to use in the object that is stored in the property
+    named :attr:`knspace_key`, of this instance. I.e.
+    `object = getattr(self, self.knspace_key)`.
+
+    If that object has a knspace property, then we return its value. Otherwise,
+    we go further up, e.g. with `getattr(object, self.knspace_key)` and look
+    for its `knspace` property.
+
+    Finally, if we reach a value of `None`, or :attr:`knspace_key` was `None`,
+    the default :attr:`~kivy.uix.behaviors.knspace.knspace` namespace is
+    returned.
+
+    If :attr:`knspace` is set to the string `'fork'`, the current namespace
+    in :attr:`knspace` will be forked with :meth:`KNSpace.fork` and the
+    resulting namespace will be assigned to this instance's :attr:`knspace`.
+    See the module examples for a motivating example.
+
+    Both `rebind` and `allownone` are `True`.
+    '''
+
+    knspace_key = StringProperty('parent', allownone=True)
+    '''The name of the property of this instance, to use to search upwards for
+    a namespace to use by this instance. Defaults to `'parent'` so that we'll
+    search the parent tree. See :attr:`knspace`.
+
+    When `None`, we won't search the parent tree for the namespace.
+    `allownone` is `True`.
+    '''
+
+    def _get_knsname(self):
+        return self._knsname
+
+    def _set_knsname(self, value):
+        old_name = self._knsname
+        knspace = self.knspace
+        if old_name and knspace and getattr(knspace, old_name) == self:
+            setattr(knspace, old_name, None)
+
+        self._knsname = value
+        if value:
+            if knspace:
+                setattr(knspace, value, self)
+            else:
+                raise ValueError('Object has name "{}", but no namespace'.
+                                 format(value))
+
+    knsname = AliasProperty(
+        _get_knsname, _set_knsname, bind=('_knsname', ), cache=False)
+    '''The name given to this instance. If named, the name will be added to the
+    associated :attr:`knspace` namespace, which will then point to the
+    `proxy_ref` of this instance.
+
+    When named, one can access this object by e.g. self.knspace.name, where
+    `name` is the given name of this instance. See :attr:`knspace` and the
+    module description for more details.
+    '''
+
+
+knspace = register_context('knspace', KNSpace)
+'''The default :class:`KNSpace` namespace. See :attr:`KNSpaceBehavior.knspace`
+for more details.
+'''
diff --git a/kivy/uix/behaviors/togglebutton.py b/kivy/uix/behaviors/togglebutton.py
new file mode 100644
index 0000000..652f47f
--- /dev/null
+++ b/kivy/uix/behaviors/togglebutton.py
@@ -0,0 +1,156 @@
+'''
+ToggleButton Behavior
+=====================
+
+The :class:`~kivy.uix.behaviors.togglebutton.ToggleButtonBehavior`
+`mixin <https://en.wikipedia.org/wiki/Mixin>`_ class provides
+:class:`~kivy.uix.togglebutton.ToggleButton` behavior. You can combine this
+class with other widgets, such as an :class:`~kivy.uix.image.Image`, to provide
+alternative togglebuttons that preserve Kivy togglebutton behavior.
+
+For an overview of behaviors, please refer to the :mod:`~kivy.uix.behaviors`
+documentation.
+
+Example
+-------
+
+The following example adds togglebutton behavior to an image to make a checkbox
+that behaves like a togglebutton::
+
+    from kivy.app import App
+    from kivy.uix.image import Image
+    from kivy.uix.behaviors import ToggleButtonBehavior
+
+
+    class MyButton(ToggleButtonBehavior, Image):
+        def __init__(self, **kwargs):
+            super(MyButton, self).__init__(**kwargs)
+            self.source = 'atlas://data/images/defaulttheme/checkbox_off'
+
+        def on_state(self, widget, value):
+            if value == 'down':
+                self.source = 'atlas://data/images/defaulttheme/checkbox_on'
+            else:
+                self.source = 'atlas://data/images/defaulttheme/checkbox_off'
+
+
+    class SampleApp(App):
+        def build(self):
+            return MyButton()
+
+
+    SampleApp().run()
+'''
+
+__all__ = ('ToggleButtonBehavior', )
+
+from kivy.properties import ObjectProperty, BooleanProperty
+from kivy.uix.behaviors.button import ButtonBehavior
+from weakref import ref
+
+
+class ToggleButtonBehavior(ButtonBehavior):
+    '''This `mixin <https://en.wikipedia.org/wiki/Mixin>`_ class provides
+    :mod:`~kivy.uix.togglebutton` behavior. Please see the
+    :mod:`togglebutton behaviors module <kivy.uix.behaviors.togglebutton>`
+    documentation for more information.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    __groups = {}
+
+    group = ObjectProperty(None, allownone=True)
+    '''Group of the button. If `None`, no group will be used (the button will be
+    independent). If specified, :attr:`group` must be a hashable object, like
+    a string. Only one button in a group can be in a 'down' state.
+
+    :attr:`group` is a :class:`~kivy.properties.ObjectProperty` and defaults to
+    `None`.
+    '''
+
+    allow_no_selection = BooleanProperty(True)
+    '''This specifies whether the widgets in a group allow no selection i.e.
+    everything to be deselected.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`allow_no_selection` is a :class:`BooleanProperty` and defaults to
+    `True`
+    '''
+
+    def __init__(self, **kwargs):
+        self._previous_group = None
+        super(ToggleButtonBehavior, self).__init__(**kwargs)
+
+    def on_group(self, *largs):
+        groups = ToggleButtonBehavior.__groups
+        if self._previous_group:
+            group = groups[self._previous_group]
+            for item in group[:]:
+                if item() is self:
+                    group.remove(item)
+                    break
+        group = self._previous_group = self.group
+        if group not in groups:
+            groups[group] = []
+        r = ref(self, ToggleButtonBehavior._clear_groups)
+        groups[group].append(r)
+
+    def _release_group(self, current):
+        if self.group is None:
+            return
+        group = self.__groups[self.group]
+        for item in group[:]:
+            widget = item()
+            if widget is None:
+                group.remove(item)
+            if widget is current:
+                continue
+            widget.state = 'normal'
+
+    def _do_press(self):
+        if (not self.allow_no_selection and
+                self.group and self.state == 'down'):
+            return
+
+        self._release_group(self)
+        self.state = 'normal' if self.state == 'down' else 'down'
+
+    def _do_release(self, *args):
+        pass
+
+    @staticmethod
+    def _clear_groups(wk):
+        # auto flush the element when the weak reference have been deleted
+        groups = ToggleButtonBehavior.__groups
+        for group in list(groups.values()):
+            if wk in group:
+                group.remove(wk)
+                break
+
+    @staticmethod
+    def get_widgets(groupname):
+        '''Return a list of the widgets contained in a specific group. If the
+        group doesn't exist, an empty list will be returned.
+
+        .. note::
+
+            Always release the result of this method! Holding a reference to
+            any of these widgets can prevent them from being garbage collected.
+            If in doubt, do::
+
+                l = ToggleButtonBehavior.get_widgets('mygroup')
+                # do your job
+                del l
+
+        .. warning::
+
+            It's possible that some widgets that you have previously
+            deleted are still in the list. The garbage collector might need
+            to release other objects before flushing them.
+        '''
+        groups = ToggleButtonBehavior.__groups
+        if groupname not in groups:
+            return []
+        return [x() for x in groups[groupname] if x()][:]
diff --git a/kivy/uix/behaviors/touchripple.py b/kivy/uix/behaviors/touchripple.py
new file mode 100644
index 0000000..b3d0efa
--- /dev/null
+++ b/kivy/uix/behaviors/touchripple.py
@@ -0,0 +1,318 @@
+'''
+Touch Ripple
+============
+
+.. versionadded:: 1.10.1
+
+.. warning::
+    This code is still experimental, and its API is subject to change in a
+    future version.
+
+This module contains `mixin <https://en.wikipedia.org/wiki/Mixin>`_ classes
+to add a touch ripple visual effect known from `Google Material Design
+<https://en.wikipedia.org/wiki/Material_Design>_` to widgets.
+
+For an overview of behaviors, please refer to the :mod:`~kivy.uix.behaviors`
+documentation.
+
+The class :class:`~kivy.uix.behaviors.touchripple.TouchRippleBehavior` provides
+rendering the ripple animation.
+
+The class :class:`~kivy.uix.behaviors.touchripple.TouchRippleButtonBehavior`
+basically provides the same functionality as
+:class:`~kivy.uix.behaviors.button.ButtonBehavior` but rendering the ripple
+animation instead of default press/release visualization.
+'''
+from kivy.animation import Animation
+from kivy.clock import Clock
+from kivy.graphics import CanvasBase, Color, Ellipse, ScissorPush, ScissorPop
+from kivy.properties import BooleanProperty, ListProperty, NumericProperty, \
+    ObjectProperty, StringProperty
+from kivy.uix.relativelayout import RelativeLayout
+
+
+__all__ = (
+    'TouchRippleBehavior',
+    'TouchRippleButtonBehavior'
+)
+
+
+class TouchRippleBehavior(object):
+    '''Touch ripple behavior.
+
+    Supposed to be used as mixin on widget classes.
+
+    Ripple behavior does not trigger automatically, concrete implementation
+    needs to call :func:`ripple_show` respective :func:`ripple_fade` manually.
+
+    Example
+    -------
+
+    Here we create a Label which renders the touch ripple animation on
+    interaction::
+
+        class RippleLabel(TouchRippleBehavior, Label):
+
+            def __init__(self, **kwargs):
+                super(RippleLabel, self).__init__(**kwargs)
+
+            def on_touch_down(self, touch):
+                collide_point = self.collide_point(touch.x, touch.y)
+                if collide_point:
+                    touch.grab(self)
+                    self.ripple_show(touch)
+                    return True
+                return False
+
+            def on_touch_up(self, touch):
+                if touch.grab_current is self:
+                    touch.ungrab(self)
+                    self.ripple_fade()
+                    return True
+                return False
+    '''
+
+    ripple_rad_default = NumericProperty(10)
+    '''Default radius the animation starts from.
+
+    :attr:`ripple_rad_default` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to `10`.
+    '''
+
+    ripple_duration_in = NumericProperty(.5)
+    '''Animation duration taken to show the overlay.
+
+    :attr:`ripple_duration_in` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to `0.5`.
+    '''
+
+    ripple_duration_out = NumericProperty(.2)
+    '''Animation duration taken to fade the overlay.
+
+    :attr:`ripple_duration_out` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to `0.2`.
+    '''
+
+    ripple_fade_from_alpha = NumericProperty(.5)
+    '''Alpha channel for ripple color the animation starts with.
+
+    :attr:`ripple_fade_from_alpha` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to `0.5`.
+    '''
+
+    ripple_fade_to_alpha = NumericProperty(.8)
+    '''Alpha channel for ripple color the animation targets to.
+
+    :attr:`ripple_fade_to_alpha` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to `0.8`.
+    '''
+
+    ripple_scale = NumericProperty(2.)
+    '''Max scale of the animation overlay calculated from max(width/height) of
+    the decorated widget.
+
+    :attr:`ripple_scale` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to `2.0`.
+    '''
+
+    ripple_func_in = StringProperty('in_cubic')
+    '''Animation callback for showing the overlay.
+
+    :attr:`ripple_func_in` is a :class:`~kivy.properties.StringProperty`
+    and defaults to `in_cubic`.
+    '''
+
+    ripple_func_out = StringProperty('out_quad')
+    '''Animation callback for hiding the overlay.
+
+    :attr:`ripple_func_out` is a :class:`~kivy.properties.StringProperty`
+    and defaults to `out_quad`.
+    '''
+
+    ripple_rad = NumericProperty(10)
+    ripple_pos = ListProperty([0, 0])
+    ripple_color = ListProperty((1., 1., 1., .5))
+
+    def __init__(self, **kwargs):
+        super(TouchRippleBehavior, self).__init__(**kwargs)
+        self.ripple_pane = CanvasBase()
+        self.canvas.add(self.ripple_pane)
+        self.bind(
+            ripple_color=self._ripple_set_color,
+            ripple_pos=self._ripple_set_ellipse,
+            ripple_rad=self._ripple_set_ellipse
+        )
+        self.ripple_ellipse = None
+        self.ripple_col_instruction = None
+
+    def ripple_show(self, touch):
+        '''Begin ripple animation on current widget.
+
+        Expects touch event as argument.
+        '''
+        Animation.cancel_all(self, 'ripple_rad', 'ripple_color')
+        self._ripple_reset_pane()
+        x, y = self.to_window(*self.pos)
+        width, height = self.size
+        if isinstance(self, RelativeLayout):
+            self.ripple_pos = ripple_pos = (touch.x - x, touch.y - y)
+        else:
+            self.ripple_pos = ripple_pos = (touch.x, touch.y)
+        rc = self.ripple_color
+        ripple_rad = self.ripple_rad
+        self.ripple_color = [rc[0], rc[1], rc[2], self.ripple_fade_from_alpha]
+        with self.ripple_pane:
+            ScissorPush(
+                x=int(round(x)),
+                y=int(round(y)),
+                width=int(round(width)),
+                height=int(round(height))
+            )
+            self.ripple_col_instruction = Color(rgba=self.ripple_color)
+            self.ripple_ellipse = Ellipse(
+                size=(ripple_rad, ripple_rad),
+                pos=(
+                    ripple_pos[0] - ripple_rad / 2.,
+                    ripple_pos[1] - ripple_rad / 2.
+                )
+            )
+            ScissorPop()
+        anim = Animation(
+            ripple_rad=max(width, height) * self.ripple_scale,
+            t=self.ripple_func_in,
+            ripple_color=[rc[0], rc[1], rc[2], self.ripple_fade_to_alpha],
+            duration=self.ripple_duration_in
+        )
+        anim.start(self)
+
+    def ripple_fade(self):
+        '''Finish ripple animation on current widget.
+        '''
+        Animation.cancel_all(self, 'ripple_rad', 'ripple_color')
+        width, height = self.size
+        rc = self.ripple_color
+        duration = self.ripple_duration_out
+        anim = Animation(
+            ripple_rad=max(width, height) * self.ripple_scale,
+            ripple_color=[rc[0], rc[1], rc[2], 0.],
+            t=self.ripple_func_out,
+            duration=duration
+        )
+        anim.bind(on_complete=self._ripple_anim_complete)
+        anim.start(self)
+
+    def _ripple_set_ellipse(self, instance, value):
+        ellipse = self.ripple_ellipse
+        if not ellipse:
+            return
+        ripple_pos = self.ripple_pos
+        ripple_rad = self.ripple_rad
+        ellipse.size = (ripple_rad, ripple_rad)
+        ellipse.pos = (
+            ripple_pos[0] - ripple_rad / 2.,
+            ripple_pos[1] - ripple_rad / 2.
+        )
+
+    def _ripple_set_color(self, instance, value):
+        if not self.ripple_col_instruction:
+            return
+        self.ripple_col_instruction.rgba = value
+
+    def _ripple_anim_complete(self, anim, instance):
+        self._ripple_reset_pane()
+
+    def _ripple_reset_pane(self):
+        self.ripple_rad = self.ripple_rad_default
+        self.ripple_pane.clear()
+
+
+class TouchRippleButtonBehavior(TouchRippleBehavior):
+    '''
+    This `mixin <https://en.wikipedia.org/wiki/Mixin>`_ class provides
+    a similar behavior to :class:`~kivy.uix.behaviors.button.ButtonBehavior`
+    but provides touch ripple animation instead of button pressed/released as
+    visual effect.
+
+    :Events:
+        `on_press`
+            Fired when the button is pressed.
+        `on_release`
+            Fired when the button is released (i.e. the touch/click that
+            pressed the button goes away).
+    '''
+
+    last_touch = ObjectProperty(None)
+    '''Contains the last relevant touch received by the Button. This can
+    be used in `on_press` or `on_release` in order to know which touch
+    dispatched the event.
+
+    :attr:`last_touch` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to `None`.
+    '''
+
+    always_release = BooleanProperty(False)
+    '''This determines whether or not the widget fires an `on_release` event if
+    the touch_up is outside the widget.
+
+    :attr:`always_release` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to `False`.
+    '''
+
+    def __init__(self, **kwargs):
+        self.register_event_type('on_press')
+        self.register_event_type('on_release')
+        super(TouchRippleButtonBehavior, self).__init__(**kwargs)
+
+    def on_touch_down(self, touch):
+        if super(TouchRippleButtonBehavior, self).on_touch_down(touch):
+            return True
+        if touch.is_mouse_scrolling:
+            return False
+        if not self.collide_point(touch.x, touch.y):
+            return False
+        if self in touch.ud:
+            return False
+        touch.grab(self)
+        touch.ud[self] = True
+        self.last_touch = touch
+        self.ripple_show(touch)
+        self.dispatch('on_press')
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is self:
+            return True
+        if super(TouchRippleButtonBehavior, self).on_touch_move(touch):
+            return True
+        return self in touch.ud
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return super(TouchRippleButtonBehavior, self).on_touch_up(touch)
+        assert(self in touch.ud)
+        touch.ungrab(self)
+        self.last_touch = touch
+        if self.disabled:
+            return
+        self.ripple_fade()
+        if not self.always_release and not self.collide_point(*touch.pos):
+            return
+
+        # defer on_release until ripple_fade has completed
+        def defer_release(dt):
+            self.dispatch('on_release')
+        Clock.schedule_once(defer_release, self.ripple_duration_out)
+        return True
+
+    def on_disabled(self, instance, value):
+        # ensure ripple animation completes if disabled gets set to True
+        if value:
+            self.ripple_fade()
+        return super(TouchRippleButtonBehavior, self).on_disabled(
+            instance, value)
+
+    def on_press(self):
+        pass
+
+    def on_release(self):
+        pass
diff --git a/kivy/uix/boxlayout.py b/kivy/uix/boxlayout.py
new file mode 100644
index 0000000..930da98
--- /dev/null
+++ b/kivy/uix/boxlayout.py
@@ -0,0 +1,331 @@
+'''
+Box Layout
+==========
+
+.. only:: html
+
+    .. image:: images/boxlayout.gif
+        :align: right
+
+.. only:: latex
+
+    .. image:: images/boxlayout.png
+        :align: right
+
+:class:`BoxLayout` arranges children in a vertical or horizontal box.
+
+To position widgets above/below each other, use a vertical BoxLayout::
+
+    layout = BoxLayout(orientation='vertical')
+    btn1 = Button(text='Hello')
+    btn2 = Button(text='World')
+    layout.add_widget(btn1)
+    layout.add_widget(btn2)
+
+To position widgets next to each other, use a horizontal BoxLayout. In this
+example, we use 10 pixel spacing between children; the first button covers
+70% of the horizontal space, the second covers 30%::
+
+    layout = BoxLayout(spacing=10)
+    btn1 = Button(text='Hello', size_hint=(.7, 1))
+    btn2 = Button(text='World', size_hint=(.3, 1))
+    layout.add_widget(btn1)
+    layout.add_widget(btn2)
+
+Position hints are partially working, depending on the orientation:
+
+* If the orientation is `vertical`: `x`, `right` and `center_x` will be used.
+* If the orientation is `horizontal`: `y`, `top` and `center_y` will be used.
+
+Kv Example::
+
+    BoxLayout:
+        orientation: 'vertical'
+        Label:
+            text: 'this on top'
+        Label:
+            text: 'this right aligned'
+            size_hint_x: None
+            size: self.texture_size
+            pos_hint: {'right': 1}
+        Label:
+            text: 'this on bottom'
+
+You can check the `examples/widgets/boxlayout_poshint.py` for a live example.
+
+.. note::
+
+    The `size_hint` uses the available space after subtracting all the
+    fixed-size widgets. For example, if you have a layout that is 800px
+    wide, and add three buttons like this::
+
+        btn1 = Button(text='Hello', size=(200, 100), size_hint=(None, None))
+        btn2 = Button(text='Kivy', size_hint=(.5, 1))
+        btn3 = Button(text='World', size_hint=(.5, 1))
+
+    The first button will be 200px wide as specified, the second and third
+    will be 300px each, e.g. (800-200) * 0.5
+
+
+.. versionchanged:: 1.4.1
+    Added support for `pos_hint`.
+
+'''
+
+__all__ = ('BoxLayout', )
+
+from kivy.uix.layout import Layout
+from kivy.properties import (NumericProperty, OptionProperty,
+                             VariableListProperty, ReferenceListProperty)
+
+
+class BoxLayout(Layout):
+    '''Box layout class. See module documentation for more information.
+    '''
+
+    spacing = NumericProperty(0)
+    '''Spacing between children, in pixels.
+
+    :attr:`spacing` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0.
+    '''
+
+    padding = VariableListProperty([0, 0, 0, 0])
+    '''Padding between layout box and children: [padding_left, padding_top,
+    padding_right, padding_bottom].
+
+    padding also accepts a two argument form [padding_horizontal,
+    padding_vertical] and a one argument form [padding].
+
+    .. versionchanged:: 1.7.0
+        Replaced NumericProperty with VariableListProperty.
+
+    :attr:`padding` is a :class:`~kivy.properties.VariableListProperty` and
+    defaults to [0, 0, 0, 0].
+    '''
+
+    orientation = OptionProperty('horizontal', options=(
+        'horizontal', 'vertical'))
+    '''Orientation of the layout.
+
+    :attr:`orientation` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'horizontal'. Can be 'vertical' or 'horizontal'.
+    '''
+
+    minimum_width = NumericProperty(0)
+    '''Automatically computed minimum width needed to contain all children.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`minimum_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0. It is read only.
+    '''
+
+    minimum_height = NumericProperty(0)
+    '''Automatically computed minimum height needed to contain all children.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`minimum_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0. It is read only.
+    '''
+
+    minimum_size = ReferenceListProperty(minimum_width, minimum_height)
+    '''Automatically computed minimum size needed to contain all children.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`minimum_size` is a
+    :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`minimum_width`, :attr:`minimum_height`) properties. It is read
+    only.
+    '''
+
+    def __init__(self, **kwargs):
+        super(BoxLayout, self).__init__(**kwargs)
+        update = self._trigger_layout
+        fbind = self.fbind
+        fbind('spacing', update)
+        fbind('padding', update)
+        fbind('children', update)
+        fbind('orientation', update)
+        fbind('parent', update)
+        fbind('size', update)
+        fbind('pos', update)
+
+    def _iterate_layout(self, sizes):
+        # optimize layout by preventing looking at the same attribute in a loop
+        len_children = len(sizes)
+        padding_left, padding_top, padding_right, padding_bottom = self.padding
+        spacing = self.spacing
+        orientation = self.orientation
+        padding_x = padding_left + padding_right
+        padding_y = padding_top + padding_bottom
+
+        # calculate maximum space used by size_hint
+        stretch_sum = 0.
+        has_bound = False
+        hint = [None] * len_children
+        # min size from all the None hint, and from those with sh_min
+        minimum_size_bounded = 0
+        if orientation == 'horizontal':
+            minimum_size_y = 0
+            minimum_size_none = padding_x + spacing * (len_children - 1)
+
+            for i, ((w, h), (shw, shh), _, (shw_min, shh_min),
+                    (shw_max, _)) in enumerate(sizes):
+                if shw is None:
+                    minimum_size_none += w
+                else:
+                    hint[i] = shw
+                    if shw_min:
+                        has_bound = True
+                        minimum_size_bounded += shw_min
+                    elif shw_max is not None:
+                        has_bound = True
+                    stretch_sum += shw
+
+                if shh is None:
+                    minimum_size_y = max(minimum_size_y, h)
+                elif shh_min:
+                    minimum_size_y = max(minimum_size_y, shh_min)
+
+            minimum_size_x = minimum_size_bounded + minimum_size_none
+            minimum_size_y += padding_y
+        else:
+            minimum_size_x = 0
+            minimum_size_none = padding_y + spacing * (len_children - 1)
+
+            for i, ((w, h), (shw, shh), _, (shw_min, shh_min),
+                    (_, shh_max)) in enumerate(sizes):
+                if shh is None:
+                    minimum_size_none += h
+                else:
+                    hint[i] = shh
+                    if shh_min:
+                        has_bound = True
+                        minimum_size_bounded += shh_min
+                    elif shh_max is not None:
+                        has_bound = True
+                    stretch_sum += shh
+
+                if shw is None:
+                    minimum_size_x = max(minimum_size_x, w)
+                elif shw_min:
+                    minimum_size_x = max(minimum_size_x, shw_min)
+
+            minimum_size_y = minimum_size_bounded + minimum_size_none
+            minimum_size_x += padding_x
+
+        self.minimum_size = minimum_size_x, minimum_size_y
+        # do not move the w/h get above, it's likely to change on above line
+        selfx = self.x
+        selfy = self.y
+
+        if orientation == 'horizontal':
+            stretch_space = max(0.0, self.width - minimum_size_none)
+            dim = 0
+        else:
+            stretch_space = max(0.0, self.height - minimum_size_none)
+            dim = 1
+
+        if has_bound:
+            # make sure the size_hint_min/max are not violated
+            if stretch_space < 1e-9:
+                # there's no space, so just set to min size or zero
+                stretch_sum = stretch_space = 1.
+
+                for i, val in enumerate(sizes):
+                    sh = val[1][dim]
+                    if sh is None:
+                        continue
+
+                    sh_min = val[3][dim]
+                    if sh_min is not None:
+                        hint[i] = sh_min
+                    else:
+                        hint[i] = 0.  # everything else is zero
+            else:
+                # hint gets updated in place
+                self.layout_hint_with_bounds(
+                    stretch_sum, stretch_space, minimum_size_bounded,
+                    (val[3][dim] for val in sizes),
+                    (elem[4][dim] for elem in sizes), hint)
+
+        if orientation == 'horizontal':
+            x = padding_left + selfx
+            size_y = self.height - padding_y
+            for i, (sh, ((w, h), (_, shh), pos_hint, _, _)) in enumerate(
+                    zip(reversed(hint), reversed(sizes))):
+                cy = selfy + padding_bottom
+
+                if sh:
+                    w = max(0., stretch_space * sh / stretch_sum)
+                if shh:
+                    h = max(0, shh * size_y)
+
+                for key, value in pos_hint.items():
+                    posy = value * size_y
+                    if key == 'y':
+                        cy += posy
+                    elif key == 'top':
+                        cy += posy - h
+                    elif key == 'center_y':
+                        cy += posy - (h / 2.)
+
+                yield len_children - i - 1, x, cy, w, h
+                x += w + spacing
+
+        else:
+            y = padding_bottom + selfy
+            size_x = self.width - padding_x
+            for i, (sh, ((w, h), (shw, _), pos_hint, _, _)) in enumerate(
+                    zip(hint, sizes)):
+                cx = selfx + padding_left
+
+                if sh:
+                    h = max(0., stretch_space * sh / stretch_sum)
+                if shw:
+                    w = max(0, shw * size_x)
+
+                for key, value in pos_hint.items():
+                    posx = value * size_x
+                    if key == 'x':
+                        cx += posx
+                    elif key == 'right':
+                        cx += posx - w
+                    elif key == 'center_x':
+                        cx += posx - (w / 2.)
+
+                yield i, cx, y, w, h
+                y += h + spacing
+
+    def do_layout(self, *largs):
+        children = self.children
+        if not children:
+            l, t, r, b = self.padding
+            self.minimum_size = l + r, t + b
+            return
+
+        for i, x, y, w, h in self._iterate_layout(
+                [(c.size, c.size_hint, c.pos_hint, c.size_hint_min,
+                  c.size_hint_max) for c in children]):
+            c = children[i]
+            c.pos = x, y
+            shw, shh = c.size_hint
+            if shw is None:
+                if shh is not None:
+                    c.height = h
+            else:
+                if shh is None:
+                    c.width = w
+                else:
+                    c.size = (w, h)
+
+    def add_widget(self, widget, *args, **kwargs):
+        widget.fbind('pos_hint', self._trigger_layout)
+        return super(BoxLayout, self).add_widget(widget, *args, **kwargs)
+
+    def remove_widget(self, widget, *args, **kwargs):
+        widget.funbind('pos_hint', self._trigger_layout)
+        return super(BoxLayout, self).remove_widget(widget, *args, **kwargs)
diff --git a/kivy/uix/bubble.py b/kivy/uix/bubble.py
new file mode 100644
index 0000000..54b3810
--- /dev/null
+++ b/kivy/uix/bubble.py
@@ -0,0 +1,402 @@
+'''
+Bubble
+======
+
+.. versionadded:: 1.1.0
+
+.. image:: images/bubble.jpg
+    :align: right
+
+The Bubble widget is a form of menu or a small popup where the menu options
+are stacked either vertically or horizontally.
+
+The :class:`Bubble` contains an arrow pointing in the direction you
+choose.
+
+Simple example
+--------------
+
+.. include:: ../../examples/widgets/bubble_test.py
+    :literal:
+
+Customize the Bubble
+--------------------
+
+You can choose the direction in which the arrow points::
+
+    Bubble(arrow_pos='top_mid')
+
+The widgets added to the Bubble are ordered horizontally by default, like a
+Boxlayout. You can change that by::
+
+    orientation = 'vertical'
+
+To add items to the bubble::
+
+    bubble = Bubble(orientation = 'vertical')
+    bubble.add_widget(your_widget_instance)
+
+To remove items::
+
+    bubble.remove_widget(widget)
+    or
+    bubble.clear_widgets()
+
+To access the list of children, use content.children::
+
+    bubble.content.children
+
+.. warning::
+  This is important! Do not use bubble.children
+
+To change the appearance of the bubble::
+
+    bubble.background_color = (1, 0, 0, .5) #50% translucent red
+    bubble.border = [0, 0, 0, 0]
+    background_image = 'path/to/background/image'
+    arrow_image = 'path/to/arrow/image'
+'''
+
+__all__ = ('Bubble', 'BubbleButton', 'BubbleContent')
+
+from kivy.uix.image import Image
+from kivy.uix.widget import Widget
+from kivy.uix.scatter import Scatter
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.button import Button
+from kivy.properties import ObjectProperty, StringProperty, OptionProperty, \
+    ListProperty, BooleanProperty, ColorProperty
+from kivy.clock import Clock
+from kivy.base import EventLoop
+from kivy.metrics import dp
+
+
+class BubbleButton(Button):
+    '''A button intended for use in a Bubble widget.
+    You can use a "normal" button class, but it will not look good unless
+    the background is changed.
+
+    Rather use this BubbleButton widget that is already defined and provides a
+    suitable background for you.
+    '''
+    pass
+
+
+class BubbleContent(GridLayout):
+    pass
+
+
+class Bubble(GridLayout):
+    '''Bubble class. See module documentation for more information.
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''Background color, in the format (r, g, b, a). To use it you have to set
+    either :attr:`background_image` or :attr:`arrow_image` first.
+
+    :attr:`background_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    border = ListProperty([16, 16, 16, 16])
+    '''Border used for :class:`~kivy.graphics.vertex_instructions.BorderImage`
+    graphics instruction. Used with the :attr:`background_image`.
+    It should be used when using custom backgrounds.
+
+    It must be a list of 4 values: (bottom, right, top, left). Read the
+    BorderImage instructions for more information about how to use it.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and defaults to
+    (16, 16, 16, 16)
+    '''
+
+    background_image = StringProperty(
+        'atlas://data/images/defaulttheme/bubble')
+    '''Background image of the bubble.
+
+    :attr:`background_image` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/bubble'.
+    '''
+
+    arrow_image = StringProperty(
+        'atlas://data/images/defaulttheme/bubble_arrow')
+    ''' Image of the arrow pointing to the bubble.
+
+    :attr:`arrow_image` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/bubble_arrow'.
+    '''
+
+    show_arrow = BooleanProperty(True)
+    ''' Indicates whether to show arrow.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`show_arrow` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to `True`.
+    '''
+
+    arrow_pos = OptionProperty('bottom_mid', options=(
+        'left_top', 'left_mid', 'left_bottom', 'top_left', 'top_mid',
+        'top_right', 'right_top', 'right_mid', 'right_bottom',
+        'bottom_left', 'bottom_mid', 'bottom_right'))
+    '''Specifies the position of the arrow relative to the bubble.
+    Can be one of: left_top, left_mid, left_bottom top_left, top_mid, top_right
+    right_top, right_mid, right_bottom bottom_left, bottom_mid, bottom_right.
+
+    :attr:`arrow_pos` is a :class:`~kivy.properties.OptionProperty` and
+    defaults to 'bottom_mid'.
+    '''
+
+    content = ObjectProperty(None)
+    '''This is the object where the main content of the bubble is held.
+
+    :attr:`content` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to 'None'.
+    '''
+
+    orientation = OptionProperty('horizontal',
+                                 options=('horizontal', 'vertical'))
+    '''This specifies the manner in which the children inside bubble
+    are arranged. Can be one of 'vertical' or 'horizontal'.
+
+    :attr:`orientation` is a :class:`~kivy.properties.OptionProperty` and
+    defaults to 'horizontal'.
+    '''
+
+    limit_to = ObjectProperty(None, allownone=True)
+    '''Specifies the widget to which the bubbles position is restricted.
+
+    .. versionadded:: 1.6.0
+
+    :attr:`limit_to` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to 'None'.
+    '''
+
+    border_auto_scale = OptionProperty(
+        'both_lower',
+        options=[
+            'off', 'both', 'x_only', 'y_only', 'y_full_x_lower',
+            'x_full_y_lower', 'both_lower'
+        ]
+    )
+    '''Specifies the :attr:`kivy.graphics.BorderImage.auto_scale`
+    value on the background BorderImage.
+
+    .. versionadded:: 1.11.0
+
+    :attr:`border_auto_scale` is a
+    :class:`~kivy.properties.OptionProperty` and defaults to
+    'both_lower'.
+    '''
+
+    def __init__(self, **kwargs):
+        self._prev_arrow_pos = None
+        self._arrow_layout = BoxLayout()
+        self._bk_img = Image(
+            source=self.background_image, allow_stretch=True,
+            keep_ratio=False, color=self.background_color)
+        self.background_texture = self._bk_img.texture
+        self._arrow_img = Image(source=self.arrow_image,
+                                allow_stretch=True,
+                                color=self.background_color)
+        self.content = content = BubbleContent(parent=self)
+        super(Bubble, self).__init__(**kwargs)
+        content.parent = None
+        self.add_widget(content)
+        self.on_arrow_pos()
+
+    def add_widget(self, widget, *args, **kwargs):
+        content = self.content
+        if content is None:
+            return
+        if widget == content or widget == self._arrow_img\
+                or widget == self._arrow_layout:
+            super(Bubble, self).add_widget(widget, *args, **kwargs)
+        else:
+            content.add_widget(widget, *args, **kwargs)
+
+    def remove_widget(self, widget, *args, **kwargs):
+        content = self.content
+        if not content:
+            return
+        if widget == content or widget == self._arrow_img\
+                or widget == self._arrow_layout:
+            super(Bubble, self).remove_widget(widget, *args, **kwargs)
+        else:
+            content.remove_widget(widget, *args, **kwargs)
+
+    def clear_widgets(self, *args, **kwargs):
+        if self.content:
+            self.content.clear_widgets(*args, **kwargs)
+
+    def on_show_arrow(self, instance, value):
+        self._arrow_img.opacity = int(value)
+
+    def on_parent(self, instance, value):
+        Clock.schedule_once(self._update_arrow)
+
+    def on_pos(self, instance, pos):
+        lt = self.limit_to
+
+        if lt:
+            self.limit_to = None
+            if lt is EventLoop.window:
+                x = y = 0
+                top = lt.height
+                right = lt.width
+            else:
+                x, y = lt.x, lt.y
+                top, right = lt.top, lt.right
+
+            self.x = max(self.x, x)
+            self.right = min(self.right, right)
+            self.top = min(self.top, top)
+            self.y = max(self.y, y)
+            self.limit_to = lt
+
+    def on_background_image(self, *l):
+        self._bk_img.source = self.background_image
+
+    def on_background_color(self, *l):
+        if self.content is None:
+            return
+        self._arrow_img.color = self._bk_img.color = self.background_color
+
+    def on_orientation(self, *l):
+        content = self.content
+        if not content:
+            return
+        if self.orientation[0] == 'v':
+            content.cols = 1
+            content.rows = 99
+        else:
+            content.cols = 99
+            content.rows = 1
+
+    def on_arrow_image(self, *l):
+        self._arrow_img.source = self.arrow_image
+
+    def on_arrow_pos(self, *l):
+        self_content = self.content
+        if not self_content:
+            Clock.schedule_once(self.on_arrow_pos)
+            return
+        if self_content not in self.children:
+            Clock.schedule_once(self.on_arrow_pos)
+            return
+        self_arrow_pos = self.arrow_pos
+        if self._prev_arrow_pos == self_arrow_pos:
+            return
+        self._prev_arrow_pos = self_arrow_pos
+
+        self_arrow_layout = self._arrow_layout
+        self_arrow_layout.clear_widgets()
+        self_arrow_img = self._arrow_img
+        self._sctr = self._arrow_img
+        super(Bubble, self).clear_widgets()
+        self_content.parent = None
+
+        self_arrow_img.size_hint = (1, None)
+        self_arrow_img.height = dp(self_arrow_img.texture_size[1])
+        self_arrow_img.pos = 0, 0
+        widget_list = []
+        arrow_list = []
+        parent = self_arrow_img.parent
+        if parent:
+            parent.remove_widget(self_arrow_img)
+
+        if self_arrow_pos[0] == 'b' or self_arrow_pos[0] == 't':
+            self.cols = 1
+            self.rows = 3
+            self_arrow_layout.orientation = 'horizontal'
+            self_arrow_img.width = self.width / 3
+            self_arrow_layout.size_hint = (1, None)
+            self_arrow_layout.height = self_arrow_img.height
+            if self_arrow_pos[0] == 'b':
+                if self_arrow_pos == 'bottom_mid':
+                    widget_list = (self_content, self_arrow_img)
+                else:
+                    if self_arrow_pos == 'bottom_left':
+                        arrow_list = (self_arrow_img, Widget(), Widget())
+                    elif self_arrow_pos == 'bottom_right':
+                        # add two dummy widgets
+                        arrow_list = (Widget(), Widget(), self_arrow_img)
+                    widget_list = (self_content, self_arrow_layout)
+            else:
+                sctr = Scatter(do_translation=False,
+                               rotation=180,
+                               do_rotation=False,
+                               do_scale=False,
+                               size_hint=(None, None),
+                               size=self_arrow_img.size)
+                sctr.add_widget(self_arrow_img)
+                if self_arrow_pos == 'top_mid':
+                    # add two dummy widgets
+                    arrow_list = (Widget(), sctr, Widget())
+                elif self_arrow_pos == 'top_left':
+                    arrow_list = (sctr, Widget(), Widget())
+                elif self_arrow_pos == 'top_right':
+                    arrow_list = (Widget(), Widget(), sctr)
+                widget_list = (self_arrow_layout, self_content)
+        elif self_arrow_pos[0] == 'l' or self_arrow_pos[0] == 'r':
+            self.cols = 3
+            self.rows = 1
+            self_arrow_img.width = self.height / 3
+            self_arrow_layout.orientation = 'vertical'
+            self_arrow_layout.cols = 1
+            self_arrow_layout.size_hint = (None, 1)
+            self_arrow_layout.width = self_arrow_img.height
+
+            rotation = -90 if self_arrow_pos[0] == 'l' else 90
+            self._sctr = sctr = Scatter(do_translation=False,
+                                        rotation=rotation,
+                                        do_rotation=False,
+                                        do_scale=False,
+                                        size_hint=(None, None),
+                                        size=(self_arrow_img.size))
+            sctr.add_widget(self_arrow_img)
+
+            if self_arrow_pos[-4:] == '_top':
+                arrow_list = (Widget(size_hint=(1, .07)),
+                              sctr, Widget(size_hint=(1, .3)))
+            elif self_arrow_pos[-4:] == '_mid':
+                arrow_list = (Widget(), sctr, Widget())
+                Clock.schedule_once(self._update_arrow)
+            elif self_arrow_pos[-7:] == '_bottom':
+                arrow_list = (Widget(), Widget(), sctr)
+
+            if self_arrow_pos[0] == 'l':
+                widget_list = (self_arrow_layout, self_content)
+            else:
+                widget_list = (self_content, self_arrow_layout)
+
+        # add widgets to arrow_layout
+        add = self_arrow_layout.add_widget
+        for widg in arrow_list:
+            add(widg)
+
+        # add widgets to self
+        add = self.add_widget
+        for widg in widget_list:
+            add(widg)
+
+    def _update_arrow(self, *dt):
+        if self.arrow_pos in ('left_mid', 'right_mid'):
+            self._sctr.center_y = self._arrow_layout.center_y
+
+    @property
+    def _fills_row_first(self):
+        return True
+
+    @property
+    def _fills_from_left_to_right(self):
+        return True
+
+    @property
+    def _fills_from_top_to_bottom(self):
+        return True
diff --git a/kivy/uix/button.py b/kivy/uix/button.py
new file mode 100644
index 0000000..96123c6
--- /dev/null
+++ b/kivy/uix/button.py
@@ -0,0 +1,137 @@
+'''
+Button
+======
+
+.. image:: images/button.jpg
+    :align: right
+
+The :class:`Button` is a :class:`~kivy.uix.label.Label` with associated actions
+that are triggered when the button is pressed (or released after a
+click/touch). To configure the button, the same properties (padding,
+font_size, etc) and
+:ref:`sizing system <kivy-uix-label-sizing-and-text-content>`
+are used as for the :class:`~kivy.uix.label.Label` class::
+
+    button = Button(text='Hello world', font_size=14)
+
+To attach a callback when the button is pressed (clicked/touched), use
+:class:`~kivy.uix.widget.Widget.bind`::
+
+    def callback(instance):
+        print('The button <%s> is being pressed' % instance.text)
+
+    btn1 = Button(text='Hello world 1')
+    btn1.bind(on_press=callback)
+    btn2 = Button(text='Hello world 2')
+    btn2.bind(on_press=callback)
+
+If you want to be notified every time the button state changes, you can bind
+to the :attr:`Button.state` property::
+
+    def callback(instance, value):
+        print('My button <%s> state is <%s>' % (instance, value))
+    btn1 = Button(text='Hello world 1')
+    btn1.bind(state=callback)
+
+Kv Example::
+
+    Button:
+        text: 'press me'
+        on_press: print("ouch! More gently please")
+        on_release: print("ahhh")
+        on_state:
+            print("my current state is {}".format(self.state))
+
+'''
+
+__all__ = ('Button', )
+
+from kivy.uix.label import Label
+from kivy.properties import StringProperty, ListProperty, ColorProperty
+from kivy.uix.behaviors import ButtonBehavior
+
+
+class Button(ButtonBehavior, Label):
+    '''Button class, see module documentation for more information.
+
+    .. versionchanged:: 1.8.0
+        The behavior / logic of the button has been moved to
+        :class:`~kivy.uix.behaviors.ButtonBehaviors`.
+
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''Background color, in the format (r, g, b, a).
+
+    This acts as a *multiplier* to the texture colour. The default
+    texture is grey, so just setting the background color will give
+    a darker result. To set a plain color, set the
+    :attr:`background_normal` to ``''``.
+
+    .. versionadded:: 1.0.8
+
+    The :attr:`background_color` is a
+    :class:`~kivy.properties.ColorProperty` and defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    background_normal = StringProperty(
+        'atlas://data/images/defaulttheme/button')
+    '''Background image of the button used for the default graphical
+    representation when the button is not pressed.
+
+    .. versionadded:: 1.0.4
+
+    :attr:`background_normal` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/button'.
+    '''
+
+    background_down = StringProperty(
+        'atlas://data/images/defaulttheme/button_pressed')
+    '''Background image of the button used for the default graphical
+    representation when the button is pressed.
+
+    .. versionadded:: 1.0.4
+
+    :attr:`background_down` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/button_pressed'.
+    '''
+
+    background_disabled_normal = StringProperty(
+        'atlas://data/images/defaulttheme/button_disabled')
+    '''Background image of the button used for the default graphical
+    representation when the button is disabled and not pressed.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background_disabled_normal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/button_disabled'.
+    '''
+
+    background_disabled_down = StringProperty(
+        'atlas://data/images/defaulttheme/button_disabled_pressed')
+    '''Background image of the button used for the default graphical
+    representation when the button is disabled and pressed.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background_disabled_down` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/button_disabled_pressed'.
+    '''
+
+    border = ListProperty([16, 16, 16, 16])
+    '''Border used for :class:`~kivy.graphics.vertex_instructions.BorderImage`
+    graphics instruction. Used with :attr:`background_normal` and
+    :attr:`background_down`. Can be used for custom backgrounds.
+
+    It must be a list of four values: (bottom, right, top, left). Read the
+    BorderImage instruction for more information about how to use it.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and defaults to
+    (16, 16, 16, 16)
+    '''
diff --git a/kivy/uix/camera.py b/kivy/uix/camera.py
new file mode 100644
index 0000000..88669c1
--- /dev/null
+++ b/kivy/uix/camera.py
@@ -0,0 +1,118 @@
+'''
+Camera
+======
+
+The :class:`Camera` widget is used to capture and display video from a camera.
+Once the widget is created, the texture inside the widget will be automatically
+updated. Our :class:`~kivy.core.camera.CameraBase` implementation is used under
+the hood::
+
+    cam = Camera()
+
+By default, the first camera found on your system is used. To use a different
+camera, set the index property::
+
+    cam = Camera(index=1)
+
+You can also select the camera resolution::
+
+    cam = Camera(resolution=(320, 240))
+
+.. warning::
+
+    The camera texture is not updated as soon as you have created the object.
+    The camera initialization is asynchronous, so there may be a delay before
+    the requested texture is created.
+'''
+
+__all__ = ('Camera', )
+
+from kivy.uix.image import Image
+from kivy.core.camera import Camera as CoreCamera
+from kivy.properties import NumericProperty, ListProperty, \
+    BooleanProperty
+
+
+class Camera(Image):
+    '''Camera class. See module documentation for more information.
+    '''
+
+    play = BooleanProperty(False)
+    '''Boolean indicating whether the camera is playing or not.
+    You can start/stop the camera by setting this property::
+
+        # start the camera playing at creation
+        cam = Camera(play=True)
+
+        # create the camera, and start later (default)
+        cam = Camera(play=False)
+        # and later
+        cam.play = True
+
+    :attr:`play` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    index = NumericProperty(-1)
+    '''Index of the used camera, starting from 0.
+
+    :attr:`index` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to -1 to allow auto selection.
+    '''
+
+    resolution = ListProperty([-1, -1])
+    '''Preferred resolution to use when invoking the camera. If you are using
+    [-1, -1], the resolution will be the default one::
+
+        # create a camera object with the best image available
+        cam = Camera()
+
+        # create a camera object with an image of 320x240 if possible
+        cam = Camera(resolution=(320, 240))
+
+    .. warning::
+
+        Depending on the implementation, the camera may not respect this
+        property.
+
+    :attr:`resolution` is a :class:`~kivy.properties.ListProperty` and defaults
+    to [-1, -1].
+    '''
+
+    def __init__(self, **kwargs):
+        self._camera = None
+        super(Camera, self).__init__(**kwargs)
+        if self.index == -1:
+            self.index = 0
+        on_index = self._on_index
+        fbind = self.fbind
+        fbind('index', on_index)
+        fbind('resolution', on_index)
+        on_index()
+
+    def on_tex(self, camera):
+        self.texture = texture = camera.texture
+        self.texture_size = list(texture.size)
+        self.canvas.ask_update()
+
+    def _on_index(self, *largs):
+        self._camera = None
+        if self.index < 0:
+            return
+        if self.resolution[0] < 0 or self.resolution[1] < 0:
+            self._camera = CoreCamera(index=self.index, stopped=True)
+        else:
+            self._camera = CoreCamera(index=self.index,
+                                      resolution=self.resolution, stopped=True)
+        if self.play:
+            self._camera.start()
+
+        self._camera.bind(on_texture=self.on_tex)
+
+    def on_play(self, instance, value):
+        if not self._camera:
+            return
+        if value:
+            self._camera.start()
+        else:
+            self._camera.stop()
diff --git a/kivy/uix/carousel.py b/kivy/uix/carousel.py
new file mode 100644
index 0000000..a8e7a12
--- /dev/null
+++ b/kivy/uix/carousel.py
@@ -0,0 +1,695 @@
+'''
+Carousel
+========
+
+.. image:: images/carousel.gif
+    :align: right
+
+.. versionadded:: 1.4.0
+
+The :class:`Carousel` widget provides the classic mobile-friendly carousel view
+where you can swipe between slides.
+You can add any content to the carousel and have it move horizontally or
+vertically. The carousel can display pages in a sequence or a loop.
+
+Example::
+
+    from kivy.app import App
+    from kivy.uix.carousel import Carousel
+    from kivy.uix.image import AsyncImage
+
+
+    class CarouselApp(App):
+        def build(self):
+            carousel = Carousel(direction='right')
+            for i in range(10):
+                src = "http://placehold.it/480x270.png&text=slide-%d&.png" % i
+                image = AsyncImage(source=src, allow_stretch=True)
+                carousel.add_widget(image)
+            return carousel
+
+
+    CarouselApp().run()
+
+
+Kv Example::
+
+    Carousel:
+        direction: 'right'
+        AsyncImage:
+            source: 'http://placehold.it/480x270.png&text=slide-1.png'
+        AsyncImage:
+            source: 'http://placehold.it/480x270.png&text=slide-2.png'
+        AsyncImage:
+            source: 'http://placehold.it/480x270.png&text=slide-3.png'
+        AsyncImage:
+            source: 'http://placehold.it/480x270.png&text=slide-4.png'
+
+
+.. versionchanged:: 1.5.0
+    The carousel now supports active children, like the
+    :class:`~kivy.uix.scrollview.ScrollView`. It will detect a swipe gesture
+    according to the :attr:`Carousel.scroll_timeout` and
+    :attr:`Carousel.scroll_distance` properties.
+
+    In addition, the slide container is no longer exposed by the API.
+    The impacted properties are
+    :attr:`Carousel.slides`, :attr:`Carousel.current_slide`,
+    :attr:`Carousel.previous_slide` and :attr:`Carousel.next_slide`.
+
+'''
+
+__all__ = ('Carousel', )
+
+from functools import partial
+from kivy.clock import Clock
+from kivy.factory import Factory
+from kivy.animation import Animation
+from kivy.uix.stencilview import StencilView
+from kivy.uix.relativelayout import RelativeLayout
+from kivy.properties import BooleanProperty, OptionProperty, AliasProperty, \
+    NumericProperty, ListProperty, ObjectProperty, StringProperty
+
+
+class Carousel(StencilView):
+    '''Carousel class. See module documentation for more information.
+    '''
+
+    slides = ListProperty([])
+    '''List of slides inside the Carousel. The slides are the
+    widgets added to the Carousel using the :attr:`add_widget` method.
+
+    :attr:`slides` is a :class:`~kivy.properties.ListProperty` and is
+    read-only.
+    '''
+
+    def _get_slides_container(self):
+        return [x.parent for x in self.slides]
+
+    slides_container = AliasProperty(_get_slides_container, bind=('slides',))
+
+    direction = OptionProperty('right',
+                               options=('right', 'left', 'top', 'bottom'))
+    '''Specifies the direction in which the slides are ordered. This
+    corresponds to the direction from which the user swipes to go from one
+    slide to the next. It
+    can be `right`, `left`, `top`, or `bottom`. For example, with
+    the default value of `right`, the second slide is to the right
+    of the first and the user would swipe from the right towards the
+    left to get to the second slide.
+
+    :attr:`direction` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'right'.
+    '''
+
+    min_move = NumericProperty(0.2)
+    '''Defines the minimum distance to be covered before the touch is
+    considered a swipe gesture and the Carousel content changed.
+    This is a expressed as a fraction of the Carousel's width.
+    If the movement doesn't reach this minimum value, the movement is
+    cancelled and the content is restored to its original position.
+
+    :attr:`min_move` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.2.
+    '''
+
+    anim_move_duration = NumericProperty(0.5)
+    '''Defines the duration of the Carousel animation between pages.
+
+    :attr:`anim_move_duration` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.5.
+    '''
+
+    anim_cancel_duration = NumericProperty(0.3)
+    '''Defines the duration of the animation when a swipe movement is not
+    accepted. This is generally when the user does not make a large enough
+    swipe. See :attr:`min_move`.
+
+    :attr:`anim_cancel_duration` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.3.
+    '''
+
+    loop = BooleanProperty(False)
+    '''Allow the Carousel to loop infinitely. If True, when the user tries to
+    swipe beyond last page, it will return to the first. If False, it will
+    remain on the last page.
+
+    :attr:`loop` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    def _get_index(self):
+        if self.slides:
+            return self._index % len(self.slides)
+        return None
+
+    def _set_index(self, value):
+        if self.slides:
+            self._index = value % len(self.slides)
+        else:
+            self._index = None
+
+    index = AliasProperty(_get_index, _set_index,
+                          bind=('_index', 'slides'),
+                          cache=True)
+    '''Get/Set the current slide based on the index.
+
+    :attr:`index` is an :class:`~kivy.properties.AliasProperty` and defaults
+    to 0 (the first item).
+    '''
+
+    def _prev_slide(self):
+        slides = self.slides
+        len_slides = len(slides)
+        index = self.index
+        if len_slides < 2:  # None, or 1 slide
+            return None
+        if self.loop and index == 0:
+            return slides[-1]
+        if index > 0:
+            return slides[index - 1]
+
+    previous_slide = AliasProperty(_prev_slide,
+                                   bind=('slides', 'index', 'loop'),
+                                   cache=True)
+    '''The previous slide in the Carousel. It is None if the current slide is
+    the first slide in the Carousel. This ordering reflects the order in which
+    the slides are added: their presentation varies according to the
+    :attr:`direction` property.
+
+    :attr:`previous_slide` is an :class:`~kivy.properties.AliasProperty`.
+
+    .. versionchanged:: 1.5.0
+        This property no longer exposes the slides container. It returns
+        the widget you have added.
+    '''
+
+    def _curr_slide(self):
+        if len(self.slides):
+            return self.slides[self.index or 0]
+
+    current_slide = AliasProperty(_curr_slide,
+                                  bind=('slides', 'index'),
+                                  cache=True)
+    '''The currently shown slide.
+
+    :attr:`current_slide` is an :class:`~kivy.properties.AliasProperty`.
+
+    .. versionchanged:: 1.5.0
+        The property no longer exposes the slides container. It returns
+        the widget you have added.
+    '''
+
+    def _next_slide(self):
+        if len(self.slides) < 2:  # None, or 1 slide
+            return None
+        if self.loop and self.index == len(self.slides) - 1:
+            return self.slides[0]
+        if self.index < len(self.slides) - 1:
+            return self.slides[self.index + 1]
+
+    next_slide = AliasProperty(_next_slide,
+                               bind=('slides', 'index', 'loop'),
+                               cache=True)
+    '''The next slide in the Carousel. It is None if the current slide is
+    the last slide in the Carousel. This ordering reflects the order in which
+    the slides are added: their presentation varies according to the
+    :attr:`direction` property.
+
+    :attr:`next_slide` is an :class:`~kivy.properties.AliasProperty`.
+
+    .. versionchanged:: 1.5.0
+        The property no longer exposes the slides container.
+        It returns the widget you have added.
+    '''
+
+    scroll_timeout = NumericProperty(200)
+    '''Timeout allowed to trigger the :attr:`scroll_distance`, in milliseconds.
+    If the user has not moved :attr:`scroll_distance` within the timeout,
+    no scrolling will occur and the touch event will go to the children.
+
+    :attr:`scroll_timeout` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 200 (milliseconds)
+
+    .. versionadded:: 1.5.0
+    '''
+
+    scroll_distance = NumericProperty('20dp')
+    '''Distance to move before scrolling the :class:`Carousel` in pixels. As
+    soon as the distance has been traveled, the :class:`Carousel` will start
+    to scroll, and no touch event will go to children.
+    It is advisable that you base this value on the dpi of your target device's
+    screen.
+
+    :attr:`scroll_distance` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 20dp.
+
+    .. versionadded:: 1.5.0
+    '''
+
+    anim_type = StringProperty('out_quad')
+    '''Type of animation to use while animating to the next/previous slide.
+    This should be the name of an
+    :class:`~kivy.animation.AnimationTransition` function.
+
+    :attr:`anim_type` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'out_quad'.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    ignore_perpendicular_swipes = BooleanProperty(False)
+    '''Ignore swipes on axis perpendicular to direction.
+
+    :attr:`ignore_perpendicular_swipes` is a
+    :class:`~kivy.properties.BooleanProperty` and defaults to False.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    # private properties, for internal use only ###
+    _index = NumericProperty(0, allownone=True)
+    _prev = ObjectProperty(None, allownone=True)
+    _current = ObjectProperty(None, allownone=True)
+    _next = ObjectProperty(None, allownone=True)
+    _offset = NumericProperty(0)
+    _touch = ObjectProperty(None, allownone=True)
+
+    _change_touch_mode_ev = None
+
+    def __init__(self, **kwargs):
+        self._trigger_position_visible_slides = Clock.create_trigger(
+            self._position_visible_slides, -1)
+        super(Carousel, self).__init__(**kwargs)
+        self._skip_slide = None
+        self.touch_mode_change = False
+        self._prioritize_next = False
+        self.fbind('loop', lambda *args: self._insert_visible_slides())
+
+    def load_slide(self, slide):
+        '''Animate to the slide that is passed as the argument.
+
+        .. versionchanged:: 1.8.0
+        '''
+        slides = self.slides
+        start, stop = slides.index(self.current_slide), slides.index(slide)
+        if start == stop:
+            return
+
+        self._skip_slide = stop
+        if stop > start:
+            self._prioritize_next = True
+            self._insert_visible_slides(_next_slide=slide)
+            self.load_next()
+        else:
+            self._prioritize_next = False
+            self._insert_visible_slides(_prev_slide=slide)
+            self.load_previous()
+
+    def load_previous(self):
+        '''Animate to the previous slide.
+
+        .. versionadded:: 1.7.0
+        '''
+        self.load_next(mode='prev')
+
+    def load_next(self, mode='next'):
+        '''Animate to the next slide.
+
+        .. versionadded:: 1.7.0
+        '''
+        if self.index is not None:
+            w, h = self.size
+            _direction = {
+                'top': -h / 2,
+                'bottom': h / 2,
+                'left': w / 2,
+                'right': -w / 2}
+            _offset = _direction[self.direction]
+            if mode == 'prev':
+                _offset = -_offset
+
+            self._start_animation(min_move=0, offset=_offset)
+
+    def get_slide_container(self, slide):
+        return slide.parent
+
+    @property
+    def _prev_equals_next(self):
+        return self.loop and len(self.slides) == 2
+
+    def _insert_visible_slides(self, _next_slide=None, _prev_slide=None):
+        get_slide_container = self.get_slide_container
+
+        previous_slide = _prev_slide if _prev_slide else self.previous_slide
+        if previous_slide:
+            self._prev = get_slide_container(previous_slide)
+        else:
+            self._prev = None
+
+        current_slide = self.current_slide
+        if current_slide:
+            self._current = get_slide_container(current_slide)
+        else:
+            self._current = None
+
+        next_slide = _next_slide if _next_slide else self.next_slide
+        if next_slide:
+            self._next = get_slide_container(next_slide)
+        else:
+            self._next = None
+
+        if self._prev_equals_next:
+            setattr(self, '_prev' if self._prioritize_next else '_next', None)
+
+        super_remove = super(Carousel, self).remove_widget
+        for container in self.slides_container:
+            super_remove(container)
+
+        if self._prev and self._prev.parent is not self:
+            super(Carousel, self).add_widget(self._prev)
+        if self._next and self._next.parent is not self:
+            super(Carousel, self).add_widget(self._next)
+        if self._current:
+            super(Carousel, self).add_widget(self._current)
+
+    def _position_visible_slides(self, *args):
+        slides, index = self.slides, self.index
+        no_of_slides = len(slides) - 1
+        if not slides:
+            return
+        x, y, width, height = self.x, self.y, self.width, self.height
+        _offset, direction = self._offset, self.direction[0]
+        _prev, _next, _current = self._prev, self._next, self._current
+        get_slide_container = self.get_slide_container
+        last_slide = get_slide_container(slides[-1])
+        first_slide = get_slide_container(slides[0])
+        skip_next = False
+        _loop = self.loop
+
+        if direction in 'rl':
+            xoff = x + _offset
+            x_prev = {'l': xoff + width, 'r': xoff - width}
+            x_next = {'l': xoff - width, 'r': xoff + width}
+            if _prev:
+                _prev.pos = (x_prev[direction], y)
+            elif _loop and _next and index == 0:
+                # if first slide is moving to right with direction set to right
+                # or toward left with direction set to left
+                if ((_offset > 0 and direction == 'r') or
+                        (_offset < 0 and direction == 'l')):
+                    # put last_slide before first slide
+                    last_slide.pos = (x_prev[direction], y)
+                    skip_next = True
+            if _current:
+                _current.pos = (xoff, y)
+            if skip_next:
+                return
+            if _next:
+                _next.pos = (x_next[direction], y)
+            elif _loop and _prev and index == no_of_slides:
+                if ((_offset < 0 and direction == 'r') or
+                        (_offset > 0 and direction == 'l')):
+                    first_slide.pos = (x_next[direction], y)
+        if direction in 'tb':
+            yoff = y + _offset
+            y_prev = {'t': yoff - height, 'b': yoff + height}
+            y_next = {'t': yoff + height, 'b': yoff - height}
+            if _prev:
+                _prev.pos = (x, y_prev[direction])
+            elif _loop and _next and index == 0:
+                if ((_offset > 0 and direction == 't') or
+                        (_offset < 0 and direction == 'b')):
+                    last_slide.pos = (x, y_prev[direction])
+                    skip_next = True
+            if _current:
+                _current.pos = (x, yoff)
+            if skip_next:
+                return
+            if _next:
+                _next.pos = (x, y_next[direction])
+            elif _loop and _prev and index == no_of_slides:
+                if ((_offset < 0 and direction == 't') or
+                        (_offset > 0 and direction == 'b')):
+                    first_slide.pos = (x, y_next[direction])
+
+    def on_size(self, *args):
+        size = self.size
+        for slide in self.slides_container:
+            slide.size = size
+        self._trigger_position_visible_slides()
+
+    def on_pos(self, *args):
+        self._trigger_position_visible_slides()
+
+    def on_index(self, *args):
+        self._insert_visible_slides()
+        self._trigger_position_visible_slides()
+        self._offset = 0
+
+    def on_slides(self, *args):
+        if self.slides:
+            self.index = self.index % len(self.slides)
+        self._insert_visible_slides()
+        self._trigger_position_visible_slides()
+
+    def on__offset(self, *args):
+        self._trigger_position_visible_slides()
+        # if reached full offset, switch index to next or prev
+        direction = self.direction[0]
+        _offset = self._offset
+        width = self.width
+        height = self.height
+        index = self.index
+        if self._skip_slide is not None or index is None:
+            return
+
+        # Move to next slide?
+        if (direction == 'r' and _offset <= -width) or \
+                (direction == 'l' and _offset >= width) or \
+                (direction == 't' and _offset <= - height) or \
+                (direction == 'b' and _offset >= height):
+            if self.next_slide:
+                self.index += 1
+
+        # Move to previous slide?
+        elif (direction == 'r' and _offset >= width) or \
+                (direction == 'l' and _offset <= -width) or \
+                (direction == 't' and _offset >= height) or \
+                (direction == 'b' and _offset <= -height):
+            if self.previous_slide:
+                self.index -= 1
+
+        elif self._prev_equals_next:
+            new_value = (_offset < 0) is (direction in 'rt')
+            if self._prioritize_next is not new_value:
+                self._prioritize_next = new_value
+                if new_value is (self._next is None):
+                    self._prev, self._next = self._next, self._prev
+
+    def _start_animation(self, *args, **kwargs):
+        # compute target offset for ease back, next or prev
+        new_offset = 0
+        direction = kwargs.get('direction', self.direction)[0]
+        is_horizontal = direction in 'rl'
+        extent = self.width if is_horizontal else self.height
+        min_move = kwargs.get('min_move', self.min_move)
+        _offset = kwargs.get('offset', self._offset)
+
+        if _offset < min_move * -extent:
+            new_offset = -extent
+        elif _offset > min_move * extent:
+            new_offset = extent
+
+        # if new_offset is 0, it wasn't enough to go next/prev
+        dur = self.anim_move_duration
+        if new_offset == 0:
+            dur = self.anim_cancel_duration
+
+        # detect edge cases if not looping
+        len_slides = len(self.slides)
+        index = self.index
+        if not self.loop or len_slides == 1:
+            is_first = (index == 0)
+            is_last = (index == len_slides - 1)
+            if direction in 'rt':
+                towards_prev = (new_offset > 0)
+                towards_next = (new_offset < 0)
+            else:
+                towards_prev = (new_offset < 0)
+                towards_next = (new_offset > 0)
+            if (is_first and towards_prev) or (is_last and towards_next):
+                new_offset = 0
+
+        anim = Animation(_offset=new_offset, d=dur, t=self.anim_type)
+        anim.cancel_all(self)
+
+        def _cmp(*l):
+            if self._skip_slide is not None:
+                self.index = self._skip_slide
+                self._skip_slide = None
+
+        anim.bind(on_complete=_cmp)
+        anim.start(self)
+
+    def _get_uid(self, prefix='sv'):
+        return '{0}.{1}'.format(prefix, self.uid)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            touch.ud[self._get_uid('cavoid')] = True
+            return
+        if self.disabled:
+            return True
+        if self._touch:
+            return super(Carousel, self).on_touch_down(touch)
+        Animation.cancel_all(self)
+        self._touch = touch
+        uid = self._get_uid()
+        touch.grab(self)
+        touch.ud[uid] = {
+            'mode': 'unknown',
+            'time': touch.time_start}
+        self._change_touch_mode_ev = Clock.schedule_once(
+            self._change_touch_mode, self.scroll_timeout / 1000.)
+        self.touch_mode_change = False
+        return True
+
+    def on_touch_move(self, touch):
+        if not self.touch_mode_change:
+            if self.ignore_perpendicular_swipes and \
+                    self.direction in ('top', 'bottom'):
+                if abs(touch.oy - touch.y) < self.scroll_distance:
+                    if abs(touch.ox - touch.x) > self.scroll_distance:
+                        self._change_touch_mode()
+                        self.touch_mode_change = True
+            elif self.ignore_perpendicular_swipes and \
+                    self.direction in ('right', 'left'):
+                if abs(touch.ox - touch.x) < self.scroll_distance:
+                    if abs(touch.oy - touch.y) > self.scroll_distance:
+                        self._change_touch_mode()
+                        self.touch_mode_change = True
+
+        if self._get_uid('cavoid') in touch.ud:
+            return
+        if self._touch is not touch:
+            super(Carousel, self).on_touch_move(touch)
+            return self._get_uid() in touch.ud
+        if touch.grab_current is not self:
+            return True
+        ud = touch.ud[self._get_uid()]
+        direction = self.direction[0]
+        if ud['mode'] == 'unknown':
+            if direction in 'rl':
+                distance = abs(touch.ox - touch.x)
+            else:
+                distance = abs(touch.oy - touch.y)
+            if distance > self.scroll_distance:
+                ev = self._change_touch_mode_ev
+                if ev is not None:
+                    ev.cancel()
+                ud['mode'] = 'scroll'
+        else:
+            if direction in 'rl':
+                self._offset += touch.dx
+            if direction in 'tb':
+                self._offset += touch.dy
+        return True
+
+    def on_touch_up(self, touch):
+        if self._get_uid('cavoid') in touch.ud:
+            return
+        if self in [x() for x in touch.grab_list]:
+            touch.ungrab(self)
+            self._touch = None
+            ud = touch.ud[self._get_uid()]
+            if ud['mode'] == 'unknown':
+                ev = self._change_touch_mode_ev
+                if ev is not None:
+                    ev.cancel()
+                super(Carousel, self).on_touch_down(touch)
+                Clock.schedule_once(partial(self._do_touch_up, touch), .1)
+            else:
+                self._start_animation()
+
+        else:
+            if self._touch is not touch and self.uid not in touch.ud:
+                super(Carousel, self).on_touch_up(touch)
+        return self._get_uid() in touch.ud
+
+    def _do_touch_up(self, touch, *largs):
+        super(Carousel, self).on_touch_up(touch)
+        # don't forget about grab event!
+        for x in touch.grab_list[:]:
+            touch.grab_list.remove(x)
+            x = x()
+            if not x:
+                continue
+            touch.grab_current = x
+            super(Carousel, self).on_touch_up(touch)
+        touch.grab_current = None
+
+    def _change_touch_mode(self, *largs):
+        if not self._touch:
+            return
+        self._start_animation()
+        uid = self._get_uid()
+        touch = self._touch
+        ud = touch.ud[uid]
+        if ud['mode'] == 'unknown':
+            touch.ungrab(self)
+            self._touch = None
+            super(Carousel, self).on_touch_down(touch)
+            return
+
+    def add_widget(self, widget, index=0, *args, **kwargs):
+        container = RelativeLayout(
+            size=self.size, x=self.x - self.width, y=self.y)
+        container.add_widget(widget)
+        super(Carousel, self).add_widget(container, index, *args, **kwargs)
+        if index != 0:
+            self.slides.insert(index - len(self.slides), widget)
+        else:
+            self.slides.append(widget)
+
+    def remove_widget(self, widget, *args, **kwargs):
+        # XXX be careful, the widget.parent refer to the RelativeLayout
+        # added in add_widget(). But it will break if RelativeLayout
+        # implementation change.
+        # if we passed the real widget
+        slides = self.slides
+        if widget in slides:
+            if self.index >= slides.index(widget):
+                self.index = max(0, self.index - 1)
+            container = widget.parent
+            slides.remove(widget)
+            super(Carousel, self).remove_widget(container, *args, **kwargs)
+            container.remove_widget(widget)
+            return
+        super(Carousel, self).remove_widget(widget, *args, **kwargs)
+
+    def clear_widgets(self, children=None, *args, **kwargs):
+        # `children` must be a list of slides or None
+        if children is None:
+            children = self.slides[:]
+        remove_widget = self.remove_widget
+        for widget in children:
+            remove_widget(widget)
+        super(Carousel, self).clear_widgets()
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+
+    class Example1(App):
+
+        def build(self):
+            carousel = Carousel(direction='left',
+                                loop=True)
+            for i in range(4):
+                src = "http://placehold.it/480x270.png&text=slide-%d&.png" % i
+                image = Factory.AsyncImage(source=src, allow_stretch=True)
+                carousel.add_widget(image)
+            return carousel
+
+    Example1().run()
diff --git a/kivy/uix/checkbox.py b/kivy/uix/checkbox.py
new file mode 100644
index 0000000..7067b4b
--- /dev/null
+++ b/kivy/uix/checkbox.py
@@ -0,0 +1,197 @@
+'''
+CheckBox
+========
+
+.. versionadded:: 1.4.0
+
+.. image:: images/checkbox.png
+    :align: right
+
+:class:`CheckBox` is a specific two-state button that can be either checked or
+unchecked. If the CheckBox is in a Group, it becomes a Radio button.
+As with the :class:`~kivy.uix.togglebutton.ToggleButton`, only one Radio button
+at a time can be selected when the :attr:`CheckBox.group` is set.
+
+An example usage::
+
+    from kivy.uix.checkbox import CheckBox
+
+    # ...
+
+    def on_checkbox_active(checkbox, value):
+        if value:
+            print('The checkbox', checkbox, 'is active')
+        else:
+            print('The checkbox', checkbox, 'is inactive')
+
+    checkbox = CheckBox()
+    checkbox.bind(active=on_checkbox_active)
+'''
+
+__all__ = ('CheckBox', )
+
+from kivy.properties import AliasProperty, StringProperty, ColorProperty
+from kivy.uix.behaviors import ToggleButtonBehavior
+from kivy.uix.widget import Widget
+
+
+class CheckBox(ToggleButtonBehavior, Widget):
+    '''CheckBox class, see module documentation for more information.
+    '''
+
+    def _get_active(self):
+        return self.state == 'down'
+
+    def _set_active(self, value):
+        self.state = 'down' if value else 'normal'
+
+    active = AliasProperty(
+        _get_active, _set_active, bind=('state', ), cache=True)
+    '''Indicates if the switch is active or inactive.
+
+    :attr:`active` is a boolean and reflects and sets whether the underlying
+    :attr:`~kivy.uix.button.Button.state` is 'down' (True) or 'normal' (False).
+    It is a :class:`~kivy.properties.AliasProperty`, which accepts boolean
+    values and defaults to False.
+
+    .. versionchanged:: 1.11.0
+
+        It changed from a BooleanProperty to a AliasProperty.
+    '''
+
+    background_checkbox_normal = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_off')
+    '''Background image of the checkbox used for the default graphical
+    representation when the checkbox is not active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_checkbox_normal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_off'.
+    '''
+
+    background_checkbox_down = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_on')
+    '''Background image of the checkbox used for the default graphical
+    representation when the checkbox is active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_checkbox_down` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_on'.
+    '''
+
+    background_checkbox_disabled_normal = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_disabled_off')
+    '''Background image of the checkbox used for the default graphical
+    representation when the checkbox is disabled and not active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_checkbox_disabled_normal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_disabled_off'.
+    '''
+
+    background_checkbox_disabled_down = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_disabled_on')
+    '''Background image of the checkbox used for the default graphical
+    representation when the checkbox is disabled and active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_checkbox_disabled_down` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_disabled_on'.
+    '''
+
+    background_radio_normal = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_radio_off')
+    '''Background image of the radio button used for the default graphical
+    representation when the radio button is not active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_radio_normal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_radio_off'.
+    '''
+
+    background_radio_down = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_radio_on')
+    '''Background image of the radio button used for the default graphical
+    representation when the radio button is active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_radio_down` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_radio_on'.
+    '''
+
+    background_radio_disabled_normal = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_radio_disabled_off')
+    '''Background image of the radio button used for the default graphical
+    representation when the radio button is disabled and not active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_radio_disabled_normal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_radio_disabled_off'.
+    '''
+
+    background_radio_disabled_down = StringProperty(
+        'atlas://data/images/defaulttheme/checkbox_radio_disabled_on')
+    '''Background image of the radio button used for the default graphical
+    representation when the radio button is disabled and active.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`background_radio_disabled_down` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/checkbox_radio_disabled_on'.
+    '''
+
+    color = ColorProperty([1, 1, 1, 1])
+    '''Color is used for tinting the default graphical representation
+    of checkbox and radio button (images).
+
+    Color is in the format (r, g, b, a).
+
+    .. versionadded:: 1.10.0
+
+    :attr:`color` is a
+    :class:`~kivy.properties.ColorProperty` and defaults to
+    '[1, 1, 1, 1]'.
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    def __init__(self, **kwargs):
+        self.fbind('state', self._on_state)
+        super(CheckBox, self).__init__(**kwargs)
+
+    def _on_state(self, instance, value):
+        if self.group and self.state == 'down':
+            self._release_group(self)
+
+    def on_group(self, *largs):
+        super(CheckBox, self).on_group(*largs)
+        if self.active:
+            self._release_group(self)
+
+
+if __name__ == '__main__':
+    from random import uniform
+    from kivy.base import runTouchApp
+    from kivy.uix.gridlayout import GridLayout
+    x = GridLayout(cols=4)
+    for i in range(36):
+        r, g, b = [uniform(0.2, 1.0) for j in range(3)]
+        x.add_widget(CheckBox(group='1' if i % 2 else '', color=[r, g, b, 2]))
+    runTouchApp(x)
diff --git a/kivy/uix/codeinput.py b/kivy/uix/codeinput.py
new file mode 100644
index 0000000..1fd6b69
--- /dev/null
+++ b/kivy/uix/codeinput.py
@@ -0,0 +1,238 @@
+'''
+Code Input
+==========
+
+.. versionadded:: 1.5.0
+
+.. image:: images/codeinput.jpg
+
+.. note::
+
+    This widget requires ``pygments`` package to run. Install it with ``pip``.
+
+The :class:`CodeInput` provides a box of editable highlighted text like the one
+shown in the image.
+
+It supports all the features provided by the :class:`~kivy.uix.textinput` as
+well as code highlighting for `languages supported by pygments
+<http://pygments.org/docs/lexers/>`_ along with `KivyLexer` for
+:mod:`kivy.lang` highlighting.
+
+Usage example
+-------------
+
+To create a CodeInput with highlighting for `KV language`::
+
+    from kivy.uix.codeinput import CodeInput
+    from kivy.extras.highlight import KivyLexer
+    codeinput = CodeInput(lexer=KivyLexer())
+
+To create a CodeInput with highlighting for `Cython`::
+
+    from kivy.uix.codeinput import CodeInput
+    from pygments.lexers import CythonLexer
+    codeinput = CodeInput(lexer=CythonLexer())
+
+'''
+
+__all__ = ('CodeInput', )
+
+from pygments import highlight
+from pygments import lexers
+from pygments import styles
+from pygments.formatters import BBCodeFormatter
+
+from kivy.uix.textinput import TextInput
+from kivy.core.text.markup import MarkupLabel as Label
+from kivy.cache import Cache
+from kivy.properties import ObjectProperty, OptionProperty
+from kivy.utils import get_hex_from_color, get_color_from_hex
+from kivy.uix.behaviors import CodeNavigationBehavior
+
+Cache_get = Cache.get
+Cache_append = Cache.append
+
+# TODO: color chooser for keywords/strings/...
+
+
+class CodeInput(CodeNavigationBehavior, TextInput):
+    '''CodeInput class, used for displaying highlighted code.
+    '''
+
+    lexer = ObjectProperty(None)
+    '''This holds the selected Lexer used by pygments to highlight the code.
+
+
+    :attr:`lexer` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to `PythonLexer`.
+    '''
+
+    style_name = OptionProperty(
+        'default', options=list(styles.get_all_styles())
+    )
+    '''Name of the pygments style to use for formatting.
+
+    :attr:`style_name` is an :class:`~kivy.properties.OptionProperty`
+    and defaults to ``'default'``.
+
+    '''
+
+    style = ObjectProperty(None)
+    '''The pygments style object to use for formatting.
+
+    When ``style_name`` is set, this will be changed to the
+    corresponding style object.
+
+    :attr:`style` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to ``None``
+
+    '''
+
+    def __init__(self, **kwargs):
+        stylename = kwargs.get('style_name', 'default')
+        style = kwargs['style'] if 'style' in kwargs \
+            else styles.get_style_by_name(stylename)
+        self.formatter = BBCodeFormatter(style=style)
+        self.lexer = lexers.PythonLexer()
+        self.text_color = '#000000'
+        self._label_cached = Label()
+        self.use_text_color = True
+
+        super(CodeInput, self).__init__(**kwargs)
+
+        self._line_options = kw = self._get_line_options()
+        self._label_cached = Label(**kw)
+        # use text_color as foreground color
+        text_color = kwargs.get('foreground_color')
+        if text_color:
+            self.text_color = get_hex_from_color(text_color)
+        # set foreground to white to allow text colors to show
+        # use text_color as the default color in bbcodes
+        self.use_text_color = False
+        self.foreground_color = [1, 1, 1, .999]
+        if not kwargs.get('background_color'):
+            self.background_color = [.9, .92, .92, 1]
+
+    def on_style_name(self, *args):
+        self.style = styles.get_style_by_name(self.style_name)
+        self.background_color = get_color_from_hex(self.style.background_color)
+        self._trigger_refresh_text()
+
+    def on_style(self, *args):
+        self.formatter = BBCodeFormatter(style=self.style)
+        self._trigger_update_graphics()
+
+    def _create_line_label(self, text, hint=False):
+        # Create a label from a text, using line options
+        ntext = text.replace(u'\n', u'').replace(u'\t', u' ' * self.tab_width)
+        if self.password and not hint:  # Don't replace hint_text with *
+            ntext = u'*' * len(ntext)
+        ntext = self._get_bbcode(ntext)
+        kw = self._get_line_options()
+        cid = u'{}\0{}\0{}'.format(text, self.password, kw)
+        texture = Cache_get('textinput.label', cid)
+
+        if texture is None:
+            # FIXME right now, we can't render very long line...
+            # if we move on "VBO" version as fallback, we won't need to
+            # do this.
+            # try to find the maximum text we can handle
+            label = Label(text=ntext, **kw)
+            if text.find(u'\n') > 0:
+                label.text = u''
+            else:
+                label.text = ntext
+            label.refresh()
+
+            # ok, we found it.
+            texture = label.texture
+            Cache_append('textinput.label', cid, texture)
+            label.text = ''
+        return texture
+
+    def _get_line_options(self):
+        kw = super(CodeInput, self)._get_line_options()
+        kw['markup'] = True
+        kw['valign'] = 'top'
+        kw['codeinput'] = repr(self.lexer)
+        return kw
+
+    def _get_text_width(self, text, tab_width, _label_cached):
+        # Return the width of a text, according to the current line options.
+        cid = u'{}\0{}\0{}'.format(text, self.password,
+                                   self._get_line_options())
+        width = Cache_get('textinput.width', cid)
+        if width is not None:
+            return width
+        lbl = self._create_line_label(text)
+        width = lbl.width
+        Cache_append('textinput.width', cid, width)
+        return width
+
+    def _get_bbcode(self, ntext):
+        # get bbcoded text for python
+        try:
+            ntext[0]
+            # replace brackets with special chars that aren't highlighted
+            # by pygment. can't use &bl; ... cause & is highlighted
+            ntext = ntext.replace(u'[', u'\x01').replace(u']', u'\x02')
+            ntext = highlight(ntext, self.lexer, self.formatter)
+            ntext = ntext.replace(u'\x01', u'&bl;').replace(u'\x02', u'&br;')
+            # replace special chars with &bl; and &br;
+            ntext = ''.join((u'[color=', str(self.text_color), u']',
+                             ntext, u'[/color]'))
+            ntext = ntext.replace(u'\n', u'')
+            # remove possible extra highlight options
+            ntext = ntext.replace(u'[u]', '').replace(u'[/u]', '')
+            return ntext
+        except IndexError:
+            return ''
+
+    # overridden to prevent cursor position off screen
+    def _cursor_offset(self):
+        '''Get the cursor x offset on the current line
+        '''
+        offset = 0
+        try:
+            if self.cursor_col:
+                offset = self._get_text_width(
+                    self._lines[self.cursor_row][:self.cursor_col])
+                return offset
+        except:
+            pass
+        finally:
+            return offset
+
+    def on_lexer(self, instance, value):
+        self._trigger_refresh_text()
+
+    def on_foreground_color(self, instance, text_color):
+        if not self.use_text_color:
+            self.use_text_color = True
+            return
+        self.text_color = get_hex_from_color(text_color)
+        self.use_text_color = False
+        self.foreground_color = (1, 1, 1, .999)
+        self._trigger_refresh_text()
+
+
+if __name__ == '__main__':
+    from kivy.extras.highlight import KivyLexer
+    from kivy.app import App
+
+    class CodeInputTest(App):
+        def build(self):
+            return CodeInput(lexer=KivyLexer(),
+                             font_size=12,
+                             text='''
+#:kivy 1.0
+
+<YourWidget>:
+    canvas:
+        Color:
+            rgb: .5, .5, .5
+        Rectangle:
+            pos: self.pos
+            size: self.size''')
+
+    CodeInputTest().run()
diff --git a/kivy/uix/colorpicker.py b/kivy/uix/colorpicker.py
new file mode 100644
index 0000000..4164b45
--- /dev/null
+++ b/kivy/uix/colorpicker.py
@@ -0,0 +1,485 @@
+'''
+Color Picker
+============
+
+.. versionadded:: 1.7.0
+
+.. warning::
+
+    This widget is experimental. Its use and API can change at any time until
+    this warning is removed.
+
+.. image:: images/colorpicker.png
+    :align: right
+
+The ColorPicker widget allows a user to select a color from a chromatic
+wheel where pinch and zoom can be used to change the wheel's saturation.
+Sliders and TextInputs are also provided for entering the RGBA/HSV/HEX values
+directly.
+
+Usage::
+
+    clr_picker = ColorPicker()
+    parent.add_widget(clr_picker)
+
+    # To monitor changes, we can bind to color property changes
+    def on_color(instance, value):
+        print("RGBA = ", str(value))  #  or instance.color
+        print("HSV = ", str(instance.hsv))
+        print("HEX = ", str(instance.hex_color))
+
+    clr_picker.bind(color=on_color)
+
+
+'''
+
+__all__ = ('ColorPicker', 'ColorWheel')
+
+from kivy.uix.relativelayout import RelativeLayout
+from kivy.uix.widget import Widget
+from kivy.properties import (NumericProperty, BoundedNumericProperty,
+                             ListProperty, ObjectProperty,
+                             ReferenceListProperty, StringProperty,
+                             AliasProperty)
+from kivy.clock import Clock
+from kivy.graphics import Mesh, InstructionGroup, Color
+from kivy.utils import get_color_from_hex, get_hex_from_color
+from kivy.logger import Logger
+from math import cos, sin, pi, sqrt, atan
+from colorsys import rgb_to_hsv, hsv_to_rgb
+
+
+def distance(pt1, pt2):
+    return sqrt((pt1[0] - pt2[0]) ** 2. + (pt1[1] - pt2[1]) ** 2.)
+
+
+def polar_to_rect(origin, r, theta):
+    return origin[0] + r * cos(theta), origin[1] + r * sin(theta)
+
+
+def rect_to_polar(origin, x, y):
+    if x == origin[0]:
+        if y == origin[1]:
+            return (0, 0)
+        elif y > origin[1]:
+            return (y - origin[1], pi / 2.)
+        else:
+            return (origin[1] - y, 3 * pi / 2.)
+    t = atan(float((y - origin[1])) / (x - origin[0]))
+    if x - origin[0] < 0:
+        t += pi
+
+    if t < 0:
+        t += 2 * pi
+
+    return (distance((x, y), origin), t)
+
+
+class ColorWheel(Widget):
+    '''Chromatic wheel for the ColorPicker.
+
+    .. versionchanged:: 1.7.1
+        `font_size`, `font_name` and `foreground_color` have been removed. The
+        sizing is now the same as others widget, based on 'sp'. Orientation is
+        also automatically determined according to the width/height ratio.
+
+    '''
+
+    r = BoundedNumericProperty(0, min=0, max=1)
+    '''The Red value of the color currently selected.
+
+    :attr:`r` is a :class:`~kivy.properties.BoundedNumericProperty` and
+    can be a value from 0 to 1. It defaults to 0.
+    '''
+
+    g = BoundedNumericProperty(0, min=0, max=1)
+    '''The Green value of the color currently selected.
+
+    :attr:`g` is a :class:`~kivy.properties.BoundedNumericProperty`
+    and can be a value from 0 to 1.
+    '''
+
+    b = BoundedNumericProperty(0, min=0, max=1)
+    '''The Blue value of the color currently selected.
+
+    :attr:`b` is a :class:`~kivy.properties.BoundedNumericProperty` and
+    can be a value from 0 to 1.
+    '''
+
+    a = BoundedNumericProperty(0, min=0, max=1)
+    '''The Alpha value of the color currently selected.
+
+    :attr:`a` is a :class:`~kivy.properties.BoundedNumericProperty` and
+    can be a value from 0 to 1.
+    '''
+
+    color = ReferenceListProperty(r, g, b, a)
+    '''The holds the color currently selected.
+
+    :attr:`color` is a :class:`~kivy.properties.ReferenceListProperty` and
+    contains a list of `r`, `g`, `b`, `a` values.
+    '''
+
+    _origin = ListProperty((100, 100))
+    _radius = NumericProperty(100)
+
+    _piece_divisions = NumericProperty(10)
+    _pieces_of_pie = NumericProperty(16)
+
+    _inertia_slowdown = 1.25
+    _inertia_cutoff = .25
+
+    _num_touches = 0
+    _pinch_flag = False
+
+    _hsv = ListProperty([1, 1, 1, 0])
+
+    def __init__(self, **kwargs):
+        super(ColorWheel, self).__init__(**kwargs)
+
+        pdv = self._piece_divisions
+        self.sv_s = [(float(x) / pdv, 1) for x in range(pdv)] + [
+            (1, float(y) / pdv) for y in reversed(range(pdv))]
+
+    def on__origin(self, instance, value):
+        self.init_wheel(None)
+
+    def on__radius(self, instance, value):
+        self.init_wheel(None)
+
+    def init_wheel(self, dt):
+        # initialize list to hold all meshes
+        self.canvas.clear()
+        self.arcs = []
+        self.sv_idx = 0
+        pdv = self._piece_divisions
+        ppie = self._pieces_of_pie
+
+        for r in range(pdv):
+            for t in range(ppie):
+                self.arcs.append(
+                    _ColorArc(
+                        self._radius * (float(r) / float(pdv)),
+                        self._radius * (float(r + 1) / float(pdv)),
+                        2 * pi * (float(t) / float(ppie)),
+                        2 * pi * (float(t + 1) / float(ppie)),
+                        origin=self._origin,
+                        color=(float(t) / ppie,
+                               self.sv_s[self.sv_idx + r][0],
+                               self.sv_s[self.sv_idx + r][1],
+                               1)))
+
+                self.canvas.add(self.arcs[-1])
+
+    def recolor_wheel(self):
+        ppie = self._pieces_of_pie
+        for idx, segment in enumerate(self.arcs):
+            segment.change_color(
+                sv=self.sv_s[int(self.sv_idx + idx / ppie)])
+
+    def change_alpha(self, val):
+        for idx, segment in enumerate(self.arcs):
+            segment.change_color(a=val)
+
+    def inertial_incr_sv_idx(self, dt):
+        # if its already zoomed all the way out, cancel the inertial zoom
+        if self.sv_idx == len(self.sv_s) - self._piece_divisions:
+            return False
+
+        self.sv_idx += 1
+        self.recolor_wheel()
+        if dt * self._inertia_slowdown > self._inertia_cutoff:
+            return False
+        else:
+            Clock.schedule_once(self.inertial_incr_sv_idx,
+                                dt * self._inertia_slowdown)
+
+    def inertial_decr_sv_idx(self, dt):
+        # if its already zoomed all the way in, cancel the inertial zoom
+        if self.sv_idx == 0:
+            return False
+        self.sv_idx -= 1
+        self.recolor_wheel()
+        if dt * self._inertia_slowdown > self._inertia_cutoff:
+            return False
+        else:
+            Clock.schedule_once(self.inertial_decr_sv_idx,
+                                dt * self._inertia_slowdown)
+
+    def on_touch_down(self, touch):
+        r = self._get_touch_r(touch.pos)
+        if r > self._radius:
+            return False
+
+        # code is still set up to allow pinch to zoom, but this is
+        # disabled for now since it was fiddly with small wheels.
+        # Comment out these lines and  adjust on_touch_move to reenable
+        # this.
+        if self._num_touches != 0:
+            return False
+
+        touch.grab(self)
+        self._num_touches += 1
+        touch.ud['anchor_r'] = r
+        touch.ud['orig_sv_idx'] = self.sv_idx
+        touch.ud['orig_time'] = Clock.get_time()
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is not self:
+            return
+        r = self._get_touch_r(touch.pos)
+        goal_sv_idx = (touch.ud['orig_sv_idx'] -
+                       int((r - touch.ud['anchor_r']) /
+                            (float(self._radius) / self._piece_divisions)))
+
+        if (
+            goal_sv_idx != self.sv_idx and
+            goal_sv_idx >= 0 and
+            goal_sv_idx <= len(self.sv_s) - self._piece_divisions
+        ):
+            # this is a pinch to zoom
+            self._pinch_flag = True
+            self.sv_idx = goal_sv_idx
+            self.recolor_wheel()
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+        self._num_touches -= 1
+        if self._pinch_flag:
+            if self._num_touches == 0:
+                # user was pinching, and now both fingers are up. Return
+                # to normal
+                if self.sv_idx > touch.ud['orig_sv_idx']:
+                    Clock.schedule_once(
+                        self.inertial_incr_sv_idx,
+                        (Clock.get_time() - touch.ud['orig_time']) /
+                        (self.sv_idx - touch.ud['orig_sv_idx']))
+
+                if self.sv_idx < touch.ud['orig_sv_idx']:
+                    Clock.schedule_once(
+                        self.inertial_decr_sv_idx,
+                        (Clock.get_time() - touch.ud['orig_time']) /
+                        (self.sv_idx - touch.ud['orig_sv_idx']))
+
+                self._pinch_flag = False
+                return
+            else:
+                # user was pinching, and at least one finger remains. We
+                # don't want to treat the remaining fingers as touches
+                return
+        else:
+            r, theta = rect_to_polar(self._origin, *touch.pos)
+            # if touch up is outside the wheel, ignore
+            if r >= self._radius:
+                return
+            # compute which ColorArc is being touched (they aren't
+            # widgets so we don't get collide_point) and set
+            # _hsv based on the selected ColorArc
+            piece = int((theta / (2 * pi)) * self._pieces_of_pie)
+            division = int((r / self._radius) * self._piece_divisions)
+            hsva = list(
+                self.arcs[self._pieces_of_pie * division + piece].color)
+            self.color = list(hsv_to_rgb(*hsva[:3])) + hsva[-1:]
+
+    def _get_touch_r(self, pos):
+        return distance(pos, self._origin)
+
+
+class _ColorArc(InstructionGroup):
+    def __init__(self, r_min, r_max, theta_min, theta_max,
+                 color=(0, 0, 1, 1), origin=(0, 0), **kwargs):
+        super(_ColorArc, self).__init__(**kwargs)
+        self.origin = origin
+        self.r_min = r_min
+        self.r_max = r_max
+        self.theta_min = theta_min
+        self.theta_max = theta_max
+        self.color = color
+        self.color_instr = Color(*color, mode='hsv')
+        self.add(self.color_instr)
+        self.mesh = self.get_mesh()
+        self.add(self.mesh)
+
+    def __str__(self):
+        return "r_min: %s r_max: %s theta_min: %s theta_max: %s color: %s" % (
+            self.r_min, self.r_max, self.theta_min, self.theta_max, self.color
+        )
+
+    def get_mesh(self):
+        v = []
+        # first calculate the distance between endpoints of the outer
+        # arc, so we know how many steps to use when calculating
+        # vertices
+        theta_step_outer = 0.1
+        theta = self.theta_max - self.theta_min
+        d_outer = int(theta / theta_step_outer)
+        theta_step_outer = theta / d_outer
+
+        if self.r_min == 0:
+            for x in range(0, d_outer, 2):
+                v += (polar_to_rect(self.origin, self.r_max,
+                                    self.theta_min + x * theta_step_outer
+                                    ) * 2)
+                v += polar_to_rect(self.origin, 0, 0) * 2
+                v += (polar_to_rect(self.origin, self.r_max,
+                                    self.theta_min + (x + 1) * theta_step_outer
+                                    ) * 2)
+            if not d_outer & 1:  # add a last point if d_outer is even
+                v += (polar_to_rect(self.origin, self.r_max,
+                                    self.theta_min + d_outer * theta_step_outer
+                                    ) * 2)
+        else:
+            for x in range(d_outer + 1):
+                v += (polar_to_rect(self.origin, self.r_min,
+                                    self.theta_min + x * theta_step_outer
+                                    ) * 2)
+                v += (polar_to_rect(self.origin, self.r_max,
+                                    self.theta_min + x * theta_step_outer
+                                    ) * 2)
+
+        return Mesh(vertices=v, indices=range(int(len(v) / 4)),
+                    mode='triangle_strip')
+
+    def change_color(self, color=None, color_delta=None, sv=None, a=None):
+        self.remove(self.color_instr)
+        if color is not None:
+            self.color = color
+        elif color_delta is not None:
+            self.color = [self.color[i] + color_delta[i] for i in range(4)]
+        elif sv is not None:
+            self.color = (self.color[0], sv[0], sv[1], self.color[3])
+        elif a is not None:
+            self.color = (self.color[0], self.color[1], self.color[2], a)
+        self.color_instr = Color(*self.color, mode='hsv')
+        self.insert(0, self.color_instr)
+
+
+class ColorPicker(RelativeLayout):
+    '''
+    See module documentation.
+    '''
+
+    font_name = StringProperty('data/fonts/RobotoMono-Regular.ttf')
+    '''Specifies the font used on the ColorPicker.
+
+    :attr:`font_name` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'data/fonts/RobotoMono-Regular.ttf'.
+    '''
+
+    color = ListProperty((1, 1, 1, 1))
+    '''The :attr:`color` holds the color currently selected in rgba format.
+
+    :attr:`color` is a :class:`~kivy.properties.ListProperty` and defaults to
+    (1, 1, 1, 1).
+    '''
+
+    def _get_hsv(self):
+        return rgb_to_hsv(*self.color[:3])
+
+    def _set_hsv(self, value):
+        if self._updating_clr:
+            return
+        self.set_color(value)
+
+    hsv = AliasProperty(_get_hsv, _set_hsv, bind=('color', ))
+    '''The :attr:`hsv` holds the color currently selected in hsv format.
+
+    :attr:`hsv` is a :class:`~kivy.properties.ListProperty` and defaults to
+    (1, 1, 1).
+    '''
+    def _get_hex(self):
+        return get_hex_from_color(self.color)
+
+    def _set_hex(self, value):
+        if self._updating_clr:
+            return
+        self.set_color(get_color_from_hex(value)[:4])
+
+    hex_color = AliasProperty(_get_hex, _set_hex, bind=('color',), cache=True)
+    '''The :attr:`hex_color` holds the currently selected color in hex.
+
+    :attr:`hex_color` is an :class:`~kivy.properties.AliasProperty` and
+    defaults to `#ffffffff`.
+    '''
+
+    wheel = ObjectProperty(None)
+    '''The :attr:`wheel` holds the color wheel.
+
+    :attr:`wheel` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    _update_clr_ev = _update_hex_ev = None
+
+    # now used only internally.
+    foreground_color = ListProperty((1, 1, 1, 1))
+
+    def _trigger_update_clr(self, mode, clr_idx, text):
+        if self._updating_clr:
+            return
+        self._updating_clr = True
+        self._upd_clr_list = mode, clr_idx, text
+        ev = self._update_clr_ev
+        if ev is None:
+            ev = self._update_clr_ev = Clock.create_trigger(self._update_clr)
+        ev()
+
+    def _update_clr(self, dt):
+        # to prevent interaction between hsv/rgba, we work internally using rgba
+        mode, clr_idx, text = self._upd_clr_list
+        try:
+            text = min(255, max(0, float(text)))
+            if mode == 'rgb':
+                self.color[clr_idx] = float(text) / 255.
+            else:
+                hsv = list(self.hsv[:])
+                hsv[clr_idx] = float(text) / 255.
+                self.color[:3] = hsv_to_rgb(*hsv)
+        except ValueError:
+            Logger.warning('ColorPicker: invalid value : {}'.format(text))
+        finally:
+            self._updating_clr = False
+
+    def _update_hex(self, dt):
+        try:
+            if len(self._upd_hex_list) != 9:
+                return
+            self._updating_clr = False
+            self.hex_color = self._upd_hex_list
+        finally:
+            self._updating_clr = False
+
+    def _trigger_update_hex(self, text):
+        if self._updating_clr:
+            return
+        self._updating_clr = True
+        self._upd_hex_list = text
+        ev = self._update_hex_ev
+        if ev is None:
+            ev = self._update_hex_ev = Clock.create_trigger(self._update_hex)
+        ev()
+
+    def set_color(self, color):
+        self._updating_clr = True
+        if len(color) == 3:
+            self.color[:3] = color
+        else:
+            self.color = color
+        self._updating_clr = False
+
+    def __init__(self, **kwargs):
+        self._updating_clr = False
+        super(ColorPicker, self).__init__(**kwargs)
+
+
+if __name__ in ('__android__', '__main__'):
+    from kivy.app import App
+
+    class ColorPickerApp(App):
+        def build(self):
+            cp = ColorPicker(pos_hint={'center_x': .5, 'center_y': .5},
+                             size_hint=(1, 1))
+            return cp
+    ColorPickerApp().run()
diff --git a/kivy/uix/dropdown.py b/kivy/uix/dropdown.py
new file mode 100644
index 0000000..3ab7ce2
--- /dev/null
+++ b/kivy/uix/dropdown.py
@@ -0,0 +1,391 @@
+'''
+Drop-Down List
+==============
+
+.. image:: images/dropdown.gif
+    :align: right
+
+.. versionadded:: 1.4.0
+
+A versatile drop-down list that can be used with custom widgets. It allows you
+to display a list of widgets under a displayed widget. Unlike other toolkits,
+the list of widgets can contain any type of widget: simple buttons,
+images etc.
+
+The positioning of the drop-down list is fully automatic: we will always try to
+place the dropdown list in a way that the user can select an item in the list.
+
+Basic example
+-------------
+
+A button with a dropdown list of 10 possible values. All the buttons within the
+dropdown list will trigger the dropdown :meth:`DropDown.select` method. After
+being called, the main button text will display the selection of the
+dropdown. ::
+
+    from kivy.uix.dropdown import DropDown
+    from kivy.uix.button import Button
+    from kivy.base import runTouchApp
+
+    # create a dropdown with 10 buttons
+    dropdown = DropDown()
+    for index in range(10):
+        # When adding widgets, we need to specify the height manually
+        # (disabling the size_hint_y) so the dropdown can calculate
+        # the area it needs.
+
+        btn = Button(text='Value %d' % index, size_hint_y=None, height=44)
+
+        # for each button, attach a callback that will call the select() method
+        # on the dropdown. We'll pass the text of the button as the data of the
+        # selection.
+        btn.bind(on_release=lambda btn: dropdown.select(btn.text))
+
+        # then add the button inside the dropdown
+        dropdown.add_widget(btn)
+
+    # create a big main button
+    mainbutton = Button(text='Hello', size_hint=(None, None))
+
+    # show the dropdown menu when the main button is released
+    # note: all the bind() calls pass the instance of the caller (here, the
+    # mainbutton instance) as the first argument of the callback (here,
+    # dropdown.open.).
+    mainbutton.bind(on_release=dropdown.open)
+
+    # one last thing, listen for the selection in the dropdown list and
+    # assign the data to the button text.
+    dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))
+
+    runTouchApp(mainbutton)
+
+Extending dropdown in Kv
+------------------------
+
+You could create a dropdown directly from your kv::
+
+    #:kivy 1.4.0
+    <CustomDropDown>:
+        Button:
+            text: 'My first Item'
+            size_hint_y: None
+            height: 44
+            on_release: root.select('item1')
+        Label:
+            text: 'Unselectable item'
+            size_hint_y: None
+            height: 44
+        Button:
+            text: 'My second Item'
+            size_hint_y: None
+            height: 44
+            on_release: root.select('item2')
+
+And then, create the associated python class and use it::
+
+    class CustomDropDown(DropDown):
+        pass
+
+    dropdown = CustomDropDown()
+    mainbutton = Button(text='Hello', size_hint=(None, None))
+    mainbutton.bind(on_release=dropdown.open)
+    dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))
+'''
+
+__all__ = ('DropDown', )
+
+from kivy.uix.scrollview import ScrollView
+from kivy.properties import ObjectProperty, NumericProperty, BooleanProperty
+from kivy.core.window import Window
+from kivy.lang import Builder
+from kivy.clock import Clock
+from kivy.config import Config
+
+_grid_kv = '''
+GridLayout:
+    size_hint_y: None
+    height: self.minimum_size[1]
+    cols: 1
+'''
+
+
+class DropDownException(Exception):
+    '''DropDownException class.
+    '''
+    pass
+
+
+class DropDown(ScrollView):
+    '''DropDown class. See module documentation for more information.
+
+    :Events:
+        `on_select`: data
+            Fired when a selection is done. The data of the selection is passed
+            in as the first argument and is what you pass in the :meth:`select`
+            method as the first argument.
+        `on_dismiss`:
+            .. versionadded:: 1.8.0
+
+            Fired when the DropDown is dismissed, either on selection or on
+            touching outside the widget.
+    '''
+
+    auto_width = BooleanProperty(True)
+    '''By default, the width of the dropdown will be the same as the width of
+    the attached widget. Set to False if you want to provide your own width.
+
+    :attr:`auto_width` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True.
+    '''
+
+    max_height = NumericProperty(None, allownone=True)
+    '''Indicate the maximum height that the dropdown can take. If None, it will
+    take the maximum height available until the top or bottom of the screen
+    is reached.
+
+    :attr:`max_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to None.
+    '''
+
+    dismiss_on_select = BooleanProperty(True)
+    '''By default, the dropdown will be automatically dismissed when a
+    selection has been done. Set to False to prevent the dismiss.
+
+    :attr:`dismiss_on_select` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True.
+    '''
+
+    auto_dismiss = BooleanProperty(True)
+    '''By default, the dropdown will be automatically dismissed when a
+    touch happens outside of it, this option allows to disable this
+    feature
+
+    :attr:`auto_dismiss` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    min_state_time = NumericProperty(0)
+    '''Minimum time before the :class:`~kivy.uix.DropDown` is dismissed.
+    This is used to allow for the widget inside the dropdown to display
+    a down state or for the :class:`~kivy.uix.DropDown` itself to
+    display a animation for closing.
+
+    :attr:`min_state_time` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to the `Config` value `min_state_time`.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    attach_to = ObjectProperty(allownone=True)
+    '''(internal) Property that will be set to the widget to which the
+    drop down list is attached.
+
+    The :meth:`open` method will automatically set this property whilst
+    :meth:`dismiss` will set it back to None.
+    '''
+
+    container = ObjectProperty()
+    '''(internal) Property that will be set to the container of the dropdown
+    list. It is a :class:`~kivy.uix.gridlayout.GridLayout` by default.
+    '''
+
+    _touch_started_inside = None
+
+    __events__ = ('on_select', 'on_dismiss')
+
+    def __init__(self, **kwargs):
+        self._win = None
+        if 'min_state_time' not in kwargs:
+            self.min_state_time = float(
+                Config.get('graphics', 'min_state_time'))
+        if 'container' not in kwargs:
+            c = self.container = Builder.load_string(_grid_kv)
+        else:
+            c = None
+        if 'do_scroll_x' not in kwargs:
+            self.do_scroll_x = False
+        if 'size_hint' not in kwargs:
+            if 'size_hint_x' not in kwargs:
+                self.size_hint_x = None
+            if 'size_hint_y' not in kwargs:
+                self.size_hint_y = None
+        super(DropDown, self).__init__(**kwargs)
+        if c is not None:
+            super(DropDown, self).add_widget(c)
+            self.on_container(self, c)
+        Window.bind(
+            on_key_down=self.on_key_down,
+            size=self._reposition)
+        self.fbind('size', self._reposition)
+
+    def on_key_down(self, instance, key, scancode, codepoint, modifiers):
+        if key == 27 and self.get_parent_window():
+            self.dismiss()
+            return True
+
+    def on_container(self, instance, value):
+        if value is not None:
+            self.container.bind(minimum_size=self._reposition)
+
+    def open(self, widget):
+        '''Open the dropdown list and attach it to a specific widget.
+        Depending on the position of the widget within the window and
+        the height of the dropdown, the dropdown might be above or below
+        that widget.
+        '''
+        # ensure we are not already attached
+        if self.attach_to is not None:
+            self.dismiss()
+
+        # we will attach ourself to the main window, so ensure the
+        # widget we are looking for have a window
+        self._win = widget.get_parent_window()
+        if self._win is None:
+            raise DropDownException(
+                'Cannot open a dropdown list on a hidden widget')
+
+        self.attach_to = widget
+        widget.bind(pos=self._reposition, size=self._reposition)
+        self._reposition()
+
+        # attach ourself to the main window
+        self._win.add_widget(self)
+
+    def dismiss(self, *largs):
+        '''Remove the dropdown widget from the window and detach it from
+        the attached widget.
+        '''
+        Clock.schedule_once(self._real_dismiss, self.min_state_time)
+
+    def _real_dismiss(self, *largs):
+        if self.parent:
+            self.parent.remove_widget(self)
+        if self.attach_to:
+            self.attach_to.unbind(pos=self._reposition, size=self._reposition)
+            self.attach_to = None
+        self.dispatch('on_dismiss')
+
+    def on_dismiss(self):
+        pass
+
+    def select(self, data):
+        '''Call this method to trigger the `on_select` event with the `data`
+        selection. The `data` can be anything you want.
+        '''
+        self.dispatch('on_select', data)
+        if self.dismiss_on_select:
+            self.dismiss()
+
+    def on_select(self, data):
+        pass
+
+    def add_widget(self, *args, **kwargs):
+        if self.container:
+            return self.container.add_widget(*args, **kwargs)
+        return super(DropDown, self).add_widget(*args, **kwargs)
+
+    def remove_widget(self, *args, **kwargs):
+        if self.container:
+            return self.container.remove_widget(*args, **kwargs)
+        return super(DropDown, self).remove_widget(*args, **kwargs)
+
+    def clear_widgets(self, *args, **kwargs):
+        if self.container:
+            return self.container.clear_widgets(*args, **kwargs)
+        return super(DropDown, self).clear_widgets(*args, **kwargs)
+
+    def on_motion(self, etype, me):
+        super().on_motion(etype, me)
+        return True
+
+    def on_touch_down(self, touch):
+        self._touch_started_inside = self.collide_point(*touch.pos)
+        if not self.auto_dismiss or self._touch_started_inside:
+            super(DropDown, self).on_touch_down(touch)
+        return True
+
+    def on_touch_move(self, touch):
+        if not self.auto_dismiss or self._touch_started_inside:
+            super(DropDown, self).on_touch_move(touch)
+        return True
+
+    def on_touch_up(self, touch):
+        # Explicitly test for False as None occurs when shown by on_touch_down
+        if self.auto_dismiss and self._touch_started_inside is False:
+            self.dismiss()
+        else:
+            super(DropDown, self).on_touch_up(touch)
+        self._touch_started_inside = None
+        return True
+
+    def _reposition(self, *largs):
+        # calculate the coordinate of the attached widget in the window
+        # coordinate system
+        win = self._win
+        if not win:
+            return
+        widget = self.attach_to
+        if not widget or not widget.get_parent_window():
+            return
+        wx, wy = widget.to_window(*widget.pos)
+        wright, wtop = widget.to_window(widget.right, widget.top)
+
+        if self.auto_width:
+            self.width = wright - wx
+
+        # ensure the dropdown list doesn't get out on the X axis, with a
+        # preference to 0 in case the list is too wide.
+        x = wx
+        if x + self.width > win.width:
+            x = win.width - self.width
+        if x < 0:
+            x = 0
+        self.x = x
+
+        # determine if we display the dropdown upper or lower to the widget
+        if self.max_height is not None:
+            height = min(self.max_height, self.container.minimum_height)
+        else:
+            height = self.container.minimum_height
+
+        h_bottom = wy - height
+        h_top = win.height - (wtop + height)
+        if h_bottom > 0:
+            self.top = wy
+            self.height = height
+        elif h_top > 0:
+            self.y = wtop
+            self.height = height
+        else:
+            # none of both top/bottom have enough place to display the
+            # widget at the current size. Take the best side, and fit to
+            # it.
+            if h_top < h_bottom:
+                self.top = self.height = wy
+            else:
+                self.y = wtop
+                self.height = win.height - wtop
+
+
+if __name__ == '__main__':
+    from kivy.uix.button import Button
+    from kivy.base import runTouchApp
+
+    def show_dropdown(button, *largs):
+        dp = DropDown()
+        dp.bind(on_select=lambda instance, x: setattr(button, 'text', x))
+        for i in range(10):
+            item = Button(text='hello %d' % i, size_hint_y=None, height=44)
+            item.bind(on_release=lambda btn: dp.select(btn.text))
+            dp.add_widget(item)
+        dp.open(button)
+
+    def touch_move(instance, touch):
+        instance.center = touch.pos
+
+    btn = Button(text='SHOW', size_hint=(None, None), pos=(300, 200))
+    btn.bind(on_release=show_dropdown, on_touch_move=touch_move)
+
+    runTouchApp(btn)
diff --git a/kivy/uix/effectwidget.py b/kivy/uix/effectwidget.py
new file mode 100644
index 0000000..9d3ec32
--- /dev/null
+++ b/kivy/uix/effectwidget.py
@@ -0,0 +1,772 @@
+'''
+EffectWidget
+============
+
+.. versionadded:: 1.9.0
+
+The :class:`EffectWidget` is able to apply a variety of fancy
+graphical effects to
+its children. It works by rendering to a series of
+:class:`~kivy.graphics.Fbo` instances with custom opengl fragment shaders.
+As such, effects can freely do almost anything, from inverting the
+colors of the widget, to anti-aliasing, to emulating the appearance of a
+crt monitor!
+
+.. warning::
+    This code is still experimental, and its API is subject to change in a
+    future version.
+
+The basic usage is as follows::
+
+    w = EffectWidget()
+    w.add_widget(Button(text='Hello!')
+    w.effects = [InvertEffect(), HorizontalBlurEffect(size=2.0)]
+
+The equivalent in kv would be::
+
+    #: import ew kivy.uix.effectwidget
+    EffectWidget:
+        effects: ew.InvertEffect(), ew.HorizontalBlurEffect(size=2.0)
+        Button:
+            text: 'Hello!'
+
+The effects can be a list of effects of any length, and they will be
+applied sequentially.
+
+The module comes with a range of prebuilt effects, but the interface
+is designed to make it easy to create your own. Instead of writing a
+full glsl shader, you provide a single function that takes
+some inputs based on the screen (current pixel color, current widget
+texture etc.). See the sections below for more information.
+
+Usage Guidelines
+----------------
+
+It is not efficient to resize an :class:`EffectWidget`, as
+the :class:`~kivy.graphics.Fbo` is recreated on each resize event.
+If you need to resize frequently, consider doing things a different
+way.
+
+Although some effects have adjustable parameters, it is
+*not* efficient to animate these, as the entire
+shader is reconstructed every time. You should use glsl
+uniform variables instead. The :class:`AdvancedEffectBase`
+may make this easier.
+
+.. note:: The :class:`EffectWidget` *cannot* draw outside its own
+          widget area (pos -> pos + size). Any child widgets
+          overlapping the boundary will be cut off at this point.
+
+Provided Effects
+----------------
+
+The module comes with several pre-written effects. Some have
+adjustable properties (e.g. blur radius). Please see the individual
+effect documentation for more details.
+
+- :class:`MonochromeEffect` - makes the widget grayscale.
+- :class:`InvertEffect` - inverts the widget colors.
+- :class:`ChannelMixEffect` - swaps color channels.
+- :class:`ScanlinesEffect` - displays flickering scanlines.
+- :class:`PixelateEffect` - pixelates the image.
+- :class:`HorizontalBlurEffect` - Gaussuan blurs horizontally.
+- :class:`VerticalBlurEffect` - Gaussuan blurs vertically.
+- :class:`FXAAEffect` - applies a very basic anti-aliasing.
+
+Creating Effects
+----------------
+
+Effects are designed to make it easy to create and use your own
+transformations. You do this by creating and using an instance of
+:class:`EffectBase` with your own custom :attr:`EffectBase.glsl`
+property.
+
+The glsl property is a string representing part of a glsl fragment
+shader. You can include as many functions as you like (the string
+is simply spliced into the whole shader), but it
+must implement a function :code:`effect` as below::
+
+    vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+    {
+        // ... your code here
+        return something;  // must be a vec4 representing the new color
+    }
+
+The full shader will calculate the normal pixel color at each point,
+then call your :code:`effect` function to transform it. The
+parameters are:
+
+- **color**: The normal color of the current pixel (i.e. texture
+  sampled at tex_coords).
+- **texture**: The texture containing the widget's normal background.
+- **tex_coords**: The normal texture_coords used to access texture.
+- **coords**: The pixel indices of the current pixel.
+
+The shader code also has access to two useful uniform variables,
+:code:`time` containing the time (in seconds) since the program start,
+and :code:`resolution` containing the shape (x pixels, y pixels) of
+the widget.
+
+For instance, the following simple string (taken from the `InvertEffect`)
+would invert the input color but set alpha to 1.0::
+
+    vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+    {
+        return vec4(1.0 - color.xyz, 1.0);
+    }
+
+You can also set the glsl by automatically loading the string from a
+file, simply set the :attr:`EffectBase.source` property of an effect.
+
+'''
+
+from kivy.clock import Clock
+from kivy.uix.relativelayout import RelativeLayout
+from kivy.properties import (StringProperty, ObjectProperty, ListProperty,
+                             NumericProperty, DictProperty)
+from kivy.graphics import (RenderContext, Fbo, Color, Rectangle,
+                           Translate, PushMatrix, PopMatrix, ClearColor,
+                           ClearBuffers)
+from kivy.event import EventDispatcher
+from kivy.base import EventLoop
+from kivy.resources import resource_find
+from kivy.logger import Logger
+
+__all__ = ('EffectWidget', 'EffectBase', 'AdvancedEffectBase',
+           'MonochromeEffect', 'InvertEffect', 'ChannelMixEffect',
+           'ScanlinesEffect', 'PixelateEffect',
+           'HorizontalBlurEffect', 'VerticalBlurEffect',
+           'FXAAEffect')
+
+shader_header = '''
+#ifdef GL_ES
+precision highp float;
+#endif
+
+/* Outputs from the vertex shader */
+varying vec4 frag_color;
+varying vec2 tex_coord0;
+
+/* uniform texture samplers */
+uniform sampler2D texture0;
+'''
+
+shader_uniforms = '''
+uniform vec2 resolution;
+uniform float time;
+'''
+
+shader_footer_trivial = '''
+void main (void){
+     gl_FragColor = frag_color * texture2D(texture0, tex_coord0);
+}
+'''
+
+shader_footer_effect = '''
+void main (void){
+    vec4 normal_color = frag_color * texture2D(texture0, tex_coord0);
+    vec4 effect_color = effect(normal_color, texture0, tex_coord0,
+                               gl_FragCoord.xy);
+    gl_FragColor = effect_color;
+}
+'''
+
+
+effect_trivial = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{
+    return color;
+}
+'''
+
+effect_monochrome = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{
+    float mag = 1.0/3.0 * (color.x + color.y + color.z);
+    return vec4(mag, mag, mag, color.w);
+}
+'''
+
+effect_invert = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{
+    return vec4(1.0 - color.xyz, color.w);
+}
+'''
+
+effect_mix = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{{
+    return vec4(color.{}, color.{}, color.{}, color.w);
+}}
+'''
+
+effect_blur_h = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{{
+    float dt = ({} / 4.0) * 1.0 / resolution.x;
+    vec4 sum = vec4(0.0);
+    sum += texture2D(texture, vec2(tex_coords.x - 4.0*dt, tex_coords.y))
+                     * 0.05;
+    sum += texture2D(texture, vec2(tex_coords.x - 3.0*dt, tex_coords.y))
+                     * 0.09;
+    sum += texture2D(texture, vec2(tex_coords.x - 2.0*dt, tex_coords.y))
+                     * 0.12;
+    sum += texture2D(texture, vec2(tex_coords.x - dt, tex_coords.y))
+                     * 0.15;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y))
+                     * 0.16;
+    sum += texture2D(texture, vec2(tex_coords.x + dt, tex_coords.y))
+                     * 0.15;
+    sum += texture2D(texture, vec2(tex_coords.x + 2.0*dt, tex_coords.y))
+                     * 0.12;
+    sum += texture2D(texture, vec2(tex_coords.x + 3.0*dt, tex_coords.y))
+                     * 0.09;
+    sum += texture2D(texture, vec2(tex_coords.x + 4.0*dt, tex_coords.y))
+                     * 0.05;
+    return vec4(sum.xyz, color.w);
+}}
+'''
+
+effect_blur_v = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{{
+    float dt = ({} / 4.0)
+                     * 1.0 / resolution.x;
+    vec4 sum = vec4(0.0);
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - 4.0*dt))
+                     * 0.05;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - 3.0*dt))
+                     * 0.09;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - 2.0*dt))
+                     * 0.12;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y - dt))
+                     * 0.15;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y))
+                     * 0.16;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + dt))
+                     * 0.15;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + 2.0*dt))
+                     * 0.12;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + 3.0*dt))
+                     * 0.09;
+    sum += texture2D(texture, vec2(tex_coords.x, tex_coords.y + 4.0*dt))
+                     * 0.05;
+    return vec4(sum.xyz, color.w);
+}}
+'''
+
+effect_postprocessing = '''
+vec4 effect(vec4 color, sampler2D texture, vec2 tex_coords, vec2 coords)
+{
+    vec2 q = tex_coords * vec2(1, -1);
+    vec2 uv = 0.5 + (q-0.5);//*(0.9);// + 0.1*sin(0.2*time));
+
+    vec3 oricol = texture2D(texture,vec2(q.x,1.0-q.y)).xyz;
+    vec3 col;
+
+    col.r = texture2D(texture,vec2(uv.x+0.003,-uv.y)).x;
+    col.g = texture2D(texture,vec2(uv.x+0.000,-uv.y)).y;
+    col.b = texture2D(texture,vec2(uv.x-0.003,-uv.y)).z;
+
+    col = clamp(col*0.5+0.5*col*col*1.2,0.0,1.0);
+
+    //col *= 0.5 + 0.5*16.0*uv.x*uv.y*(1.0-uv.x)*(1.0-uv.y);
+
+    col *= vec3(0.8,1.0,0.7);
+
+    col *= 0.9+0.1*sin(10.0*time+uv.y*1000.0);
+
+    col *= 0.97+0.03*sin(110.0*time);
+
+    float comp = smoothstep( 0.2, 0.7, sin(time) );
+    //col = mix( col, oricol, clamp(-2.0+2.0*q.x+3.0*comp,0.0,1.0) );
+
+    return vec4(col, color.w);
+}
+'''
+
+effect_pixelate = '''
+vec4 effect(vec4 vcolor, sampler2D texture, vec2 texcoord, vec2 pixel_coords)
+{{
+    vec2 pixelSize = {} / resolution;
+
+    vec2 xy = floor(texcoord/pixelSize)*pixelSize + pixelSize/2.0;
+
+    return texture2D(texture, xy);
+}}
+'''
+
+effect_fxaa = '''
+vec4 effect( vec4 color, sampler2D buf0, vec2 texCoords, vec2 coords)
+{
+
+    vec2 frameBufSize = resolution;
+
+    float FXAA_SPAN_MAX = 8.0;
+    float FXAA_REDUCE_MUL = 1.0/8.0;
+    float FXAA_REDUCE_MIN = 1.0/128.0;
+
+    vec3 rgbNW=texture2D(buf0,texCoords+(vec2(-1.0,-1.0)/frameBufSize)).xyz;
+    vec3 rgbNE=texture2D(buf0,texCoords+(vec2(1.0,-1.0)/frameBufSize)).xyz;
+    vec3 rgbSW=texture2D(buf0,texCoords+(vec2(-1.0,1.0)/frameBufSize)).xyz;
+    vec3 rgbSE=texture2D(buf0,texCoords+(vec2(1.0,1.0)/frameBufSize)).xyz;
+    vec3 rgbM=texture2D(buf0,texCoords).xyz;
+
+    vec3 luma=vec3(0.299, 0.587, 0.114);
+    float lumaNW = dot(rgbNW, luma);
+    float lumaNE = dot(rgbNE, luma);
+    float lumaSW = dot(rgbSW, luma);
+    float lumaSE = dot(rgbSE, luma);
+    float lumaM  = dot(rgbM, luma);
+
+    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
+    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
+
+    vec2 dir;
+    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
+    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
+
+    float dirReduce = max(
+        (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL),
+        FXAA_REDUCE_MIN);
+
+    float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
+
+    dir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX),
+          max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
+          dir * rcpDirMin)) / frameBufSize;
+
+    vec3 rgbA = (1.0/2.0) * (
+        texture2D(buf0, texCoords.xy + dir * (1.0/3.0 - 0.5)).xyz +
+        texture2D(buf0, texCoords.xy + dir * (2.0/3.0 - 0.5)).xyz);
+    vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
+        texture2D(buf0, texCoords.xy + dir * (0.0/3.0 - 0.5)).xyz +
+        texture2D(buf0, texCoords.xy + dir * (3.0/3.0 - 0.5)).xyz);
+    float lumaB = dot(rgbB, luma);
+
+    vec4 return_color;
+    if((lumaB < lumaMin) || (lumaB > lumaMax)){
+        return_color = vec4(rgbA, color.w);
+    }else{
+        return_color = vec4(rgbB, color.w);
+    }
+
+    return return_color;
+}
+'''
+
+
+class EffectBase(EventDispatcher):
+    '''The base class for GLSL effects. It simply returns its input.
+
+    See the module documentation for more details.
+
+    '''
+
+    glsl = StringProperty(effect_trivial)
+    '''The glsl string defining your effect function. See the
+    module documentation for more details.
+
+    :attr:`glsl` is a :class:`~kivy.properties.StringProperty` and
+    defaults to
+    a trivial effect that returns its input.
+    '''
+
+    source = StringProperty('')
+    '''The (optional) filename from which to load the :attr:`glsl`
+    string.
+
+    :attr:`source` is a :class:`~kivy.properties.StringProperty` and
+    defaults to ''.
+    '''
+
+    fbo = ObjectProperty(None, allownone=True)
+    '''The fbo currently using this effect. The :class:`EffectBase`
+    automatically handles this.
+
+    :attr:`fbo` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super(EffectBase, self).__init__(*args, **kwargs)
+        fbind = self.fbind
+        fbo_shader = self.set_fbo_shader
+        fbind('fbo', fbo_shader)
+        fbind('glsl', fbo_shader)
+        fbind('source', self._load_from_source)
+
+    def set_fbo_shader(self, *args):
+        '''Sets the :class:`~kivy.graphics.Fbo`'s shader by splicing
+        the :attr:`glsl` string into a full fragment shader.
+
+        The full shader is made up of :code:`shader_header +
+        shader_uniforms + self.glsl + shader_footer_effect`.
+        '''
+        if self.fbo is None:
+            return
+        self.fbo.set_fs(shader_header + shader_uniforms + self.glsl +
+                        shader_footer_effect)
+
+    def _load_from_source(self, *args):
+        '''(internal) Loads the glsl string from a source file.'''
+        source = self.source
+        if not source:
+            return
+        filename = resource_find(source)
+        if filename is None:
+            return Logger.error('Error reading file {filename}'.
+                                format(filename=source))
+        with open(filename) as fileh:
+            self.glsl = fileh.read()
+
+
+class AdvancedEffectBase(EffectBase):
+    '''An :class:`EffectBase` with additional behavior to easily
+    set and update uniform variables in your shader.
+
+    This class is provided for convenience when implementing your own
+    effects: it is not used by any of those provided with Kivy.
+
+    In addition to your base glsl string that must be provided as
+    normal, the :class:`AdvancedEffectBase` has an extra property
+    :attr:`uniforms`, a dictionary of name-value pairs. Whenever
+    a value is changed, the new value for the uniform variable is
+    uploaded to the shader.
+
+    You must still manually declare your uniform variables at the top
+    of your glsl string.
+    '''
+
+    uniforms = DictProperty({})
+    '''A dictionary of uniform variable names and their values. These
+    are automatically uploaded to the :attr:`fbo` shader if appropriate.
+
+    uniforms is a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super(AdvancedEffectBase, self).__init__(*args, **kwargs)
+        self.fbind('uniforms', self._update_uniforms)
+
+    def _update_uniforms(self, *args):
+        if self.fbo is None:
+            return
+        for key, value in self.uniforms.items():
+            self.fbo[key] = value
+
+    def set_fbo_shader(self, *args):
+        super(AdvancedEffectBase, self).set_fbo_shader(*args)
+        self._update_uniforms()
+
+
+class MonochromeEffect(EffectBase):
+    '''Returns its input colors in monochrome.'''
+    def __init__(self, *args, **kwargs):
+        super(MonochromeEffect, self).__init__(*args, **kwargs)
+        self.glsl = effect_monochrome
+
+
+class InvertEffect(EffectBase):
+    '''Inverts the colors in the input.'''
+    def __init__(self, *args, **kwargs):
+        super(InvertEffect, self).__init__(*args, **kwargs)
+        self.glsl = effect_invert
+
+
+class ScanlinesEffect(EffectBase):
+    '''Adds scanlines to the input.'''
+    def __init__(self, *args, **kwargs):
+        super(ScanlinesEffect, self).__init__(*args, **kwargs)
+        self.glsl = effect_postprocessing
+
+
+class ChannelMixEffect(EffectBase):
+    '''Mixes the color channels of the input according to the order
+    property. Channels may be arbitrarily rearranged or repeated.'''
+
+    order = ListProperty([1, 2, 0])
+    '''The new sorted order of the rgb channels.
+
+    order is a :class:`~kivy.properties.ListProperty` and defaults to
+    [1, 2, 0], corresponding to (g, b, r).
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super(ChannelMixEffect, self).__init__(*args, **kwargs)
+        self.do_glsl()
+
+    def on_order(self, *args):
+        self.do_glsl()
+
+    def do_glsl(self):
+        letters = [{0: 'x', 1: 'y', 2: 'z'}[i] for i in self.order]
+        self.glsl = effect_mix.format(*letters)
+
+
+class PixelateEffect(EffectBase):
+    '''Pixelates the input according to its
+    :attr:`~PixelateEffect.pixel_size`'''
+
+    pixel_size = NumericProperty(10)
+    '''
+    Sets the size of a new 'pixel' in the effect, in terms of number of
+    'real' pixels.
+
+    pixel_size is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 10.
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super(PixelateEffect, self).__init__(*args, **kwargs)
+        self.do_glsl()
+
+    def on_pixel_size(self, *args):
+        self.do_glsl()
+
+    def do_glsl(self):
+        self.glsl = effect_pixelate.format(float(self.pixel_size))
+
+
+class HorizontalBlurEffect(EffectBase):
+    '''Blurs the input horizontally, with the width given by
+    :attr:`~HorizontalBlurEffect.size`.'''
+
+    size = NumericProperty(4.0)
+    '''The blur width in pixels.
+
+    size is a :class:`~kivy.properties.NumericProperty` and defaults to
+    4.0.
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super(HorizontalBlurEffect, self).__init__(*args, **kwargs)
+        self.do_glsl()
+
+    def on_size(self, *args):
+        self.do_glsl()
+
+    def do_glsl(self):
+        self.glsl = effect_blur_h.format(float(self.size))
+
+
+class VerticalBlurEffect(EffectBase):
+    '''Blurs the input vertically, with the width given by
+    :attr:`~VerticalBlurEffect.size`.'''
+
+    size = NumericProperty(4.0)
+    '''The blur width in pixels.
+
+    size is a :class:`~kivy.properties.NumericProperty` and defaults to
+    4.0.
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super(VerticalBlurEffect, self).__init__(*args, **kwargs)
+        self.do_glsl()
+
+    def on_size(self, *args):
+        self.do_glsl()
+
+    def do_glsl(self):
+        self.glsl = effect_blur_v.format(float(self.size))
+
+
+class FXAAEffect(EffectBase):
+    '''Applies very simple anti-aliasing via fxaa.'''
+    def __init__(self, *args, **kwargs):
+        super(FXAAEffect, self).__init__(*args, **kwargs)
+        self.glsl = effect_fxaa
+
+
+class EffectFbo(Fbo):
+    '''An :class:`~kivy.graphics.Fbo` with extra functionality that allows
+    attempts to set a new shader. See :meth:`set_fs`.
+    '''
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("with_stencilbuffer", True)
+        super(EffectFbo, self).__init__(*args, **kwargs)
+        self.texture_rectangle = None
+
+    def set_fs(self, value):
+        '''Attempt to set the fragment shader to the given value.
+        If setting the shader fails, the existing one is preserved and an
+        exception is raised.
+        '''
+        shader = self.shader
+        old_value = shader.fs
+        shader.fs = value
+        if not shader.success:
+            shader.fs = old_value
+            raise Exception('Setting new shader failed.')
+
+
+class EffectWidget(RelativeLayout):
+    '''
+    Widget with the ability to apply a series of graphical effects to
+    its children. See the module documentation for more information on
+    setting effects and creating your own.
+    '''
+
+    background_color = ListProperty((0, 0, 0, 0))
+    '''This defines the background color to be used for the fbo in the
+    EffectWidget.
+
+    :attr:`background_color` is a :class:`ListProperty` defaults to
+    (0, 0, 0, 0)
+    '''
+
+    texture = ObjectProperty(None)
+    '''The output texture of the final :class:`~kivy.graphics.Fbo` after
+    all effects have been applied.
+
+    texture is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    effects = ListProperty([])
+    '''List of all the effects to be applied. These should all be
+    instances or subclasses of :class:`EffectBase`.
+
+    effects is a :class:`ListProperty` and defaults to [].
+    '''
+
+    fbo_list = ListProperty([])
+    '''(internal) List of all the fbos that are being used to apply
+    the effects.
+
+    fbo_list is a :class:`ListProperty` and defaults to [].
+    '''
+
+    _bound_effects = ListProperty([])
+    '''(internal) List of effect classes that have been given an fbo to
+    manage. This is necessary so that the fbo can be removed if the
+    effect is no longer in use.
+
+    _bound_effects is a :class:`ListProperty` and defaults to [].
+    '''
+
+    def __init__(self, **kwargs):
+        # Make sure opengl context exists
+        EventLoop.ensure_window()
+
+        self.canvas = RenderContext(use_parent_projection=True,
+                                    use_parent_modelview=True)
+
+        with self.canvas:
+            self.fbo = Fbo(size=self.size)
+
+        with self.fbo.before:
+            PushMatrix()
+        with self.fbo:
+            ClearColor(0, 0, 0, 0)
+            ClearBuffers()
+            self._background_color = Color(*self.background_color)
+            self.fbo_rectangle = Rectangle(size=self.size)
+        with self.fbo.after:
+            PopMatrix()
+
+        super(EffectWidget, self).__init__(**kwargs)
+
+        Clock.schedule_interval(self._update_glsl, 0)
+
+        fbind = self.fbind
+        fbo_setup = self.refresh_fbo_setup
+        fbind('size', fbo_setup)
+        fbind('effects', fbo_setup)
+        fbind('background_color', self._refresh_background_color)
+
+        self.refresh_fbo_setup()
+        self._refresh_background_color()  # In case this was changed in kwargs
+
+    def _refresh_background_color(self, *args):
+        self._background_color.rgba = self.background_color
+
+    def _update_glsl(self, *largs):
+        '''(internal) Passes new time and resolution uniform
+        variables to the shader.
+        '''
+        time = Clock.get_boottime()
+        resolution = [float(size) for size in self.size]
+        self.canvas['time'] = time
+        self.canvas['resolution'] = resolution
+        for fbo in self.fbo_list:
+            fbo['time'] = time
+            fbo['resolution'] = resolution
+
+    def refresh_fbo_setup(self, *args):
+        '''(internal) Creates and assigns one :class:`~kivy.graphics.Fbo`
+        per effect, and makes sure all sizes etc. are correct and
+        consistent.
+        '''
+        # Add/remove fbos until there is one per effect
+        while len(self.fbo_list) < len(self.effects):
+            with self.canvas:
+                new_fbo = EffectFbo(size=self.size)
+            with new_fbo:
+                ClearColor(0, 0, 0, 0)
+                ClearBuffers()
+                Color(1, 1, 1, 1)
+                new_fbo.texture_rectangle = Rectangle(size=self.size)
+
+                new_fbo.texture_rectangle.size = self.size
+            self.fbo_list.append(new_fbo)
+        while len(self.fbo_list) > len(self.effects):
+            old_fbo = self.fbo_list.pop()
+            self.canvas.remove(old_fbo)
+
+        # Remove fbos from unused effects
+        for effect in self._bound_effects:
+            if effect not in self.effects:
+                effect.fbo = None
+        self._bound_effects = self.effects
+
+        # Do resizing etc.
+        self.fbo.size = self.size
+        self.fbo_rectangle.size = self.size
+        for i in range(len(self.fbo_list)):
+            self.fbo_list[i].size = self.size
+            self.fbo_list[i].texture_rectangle.size = self.size
+
+        # If there are no effects, just draw our main fbo
+        if len(self.fbo_list) == 0:
+            self.texture = self.fbo.texture
+            return
+
+        for i in range(1, len(self.fbo_list)):
+            fbo = self.fbo_list[i]
+            fbo.texture_rectangle.texture = self.fbo_list[i - 1].texture
+
+        # Build effect shaders
+        for effect, fbo in zip(self.effects, self.fbo_list):
+            effect.fbo = fbo
+
+        self.fbo_list[0].texture_rectangle.texture = self.fbo.texture
+        self.texture = self.fbo_list[-1].texture
+
+        for fbo in self.fbo_list:
+            fbo.draw()
+        self.fbo.draw()
+
+    def add_widget(self, *args, **kwargs):
+        # Add the widget to our Fbo instead of the normal canvas
+        c = self.canvas
+        self.canvas = self.fbo
+        super(EffectWidget, self).add_widget(*args, **kwargs)
+        self.canvas = c
+
+    def remove_widget(self, *args, **kwargs):
+        # Remove the widget from our Fbo instead of the normal canvas
+        c = self.canvas
+        self.canvas = self.fbo
+        super(EffectWidget, self).remove_widget(*args, **kwargs)
+        self.canvas = c
+
+    def clear_widgets(self, *args, **kwargs):
+        # Clear widgets from our Fbo instead of the normal canvas
+        c = self.canvas
+        self.canvas = self.fbo
+        super(EffectWidget, self).clear_widgets(*args, **kwargs)
+        self.canvas = c
diff --git a/kivy/uix/filechooser.py b/kivy/uix/filechooser.py
new file mode 100644
index 0000000..2786be0
--- /dev/null
+++ b/kivy/uix/filechooser.py
@@ -0,0 +1,1134 @@
+'''
+FileChooser
+===========
+
+The FileChooser module provides various classes for describing, displaying and
+browsing file systems.
+
+Simple widgets
+--------------
+
+There are two ready-to-use widgets that provide views of the file system. Each
+of these present the files and folders in a different style.
+
+The :class:`FileChooserListView` displays file entries as text items in a
+vertical list, where folders can be collapsed and expanded.
+
+.. image:: images/filechooser_list.png
+
+The :class:`FileChooserIconView` presents icons and text from left to right,
+wrapping them as required.
+
+.. image:: images/filechooser_icon.png
+
+They both provide for scrolling, selection and basic user interaction.
+Please refer to the :class:`FileChooserController` for details on supported
+events and properties.
+
+Widget composition
+------------------
+
+FileChooser classes adopt a
+`MVC <https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller>`_
+design. They are exposed so that you to extend and customize your file chooser
+according to your needs.
+
+The FileChooser classes can be categorized as follows:
+
+* Models are represented by concrete implementations of the
+  :class:`FileSystemAbstract` class, such as the :class:`FileSystemLocal`.
+
+* Views are represented by the :class:`FileChooserListLayout` and
+  :class:`FileChooserIconLayout` classes. These are used by the
+  :class:`FileChooserListView` and :class:`FileChooserIconView` widgets
+  respectively.
+
+* Controllers are represented by concrete implementations of the
+  :class:`FileChooserController`, namely the :class:`FileChooser`,
+  :class:`FileChooserIconView` and :class:`FileChooserListView` classes.
+
+This means you can define your own views or provide :class:`FileSystemAbstract`
+implementations for alternative file systems for use with these widgets.
+The :class:`FileChooser` can be used as a controller for handling multiple,
+synchronized views of the same path. By combining these elements, you can add
+your own views and file systems and have them easily interact with the existing
+components.
+
+Usage example
+-------------
+
+main.py
+
+.. include:: ../../examples/RST_Editor/main.py
+    :literal:
+
+editor.kv
+
+.. highlight:: kv
+
+.. include:: ../../examples/RST_Editor/editor.kv
+    :literal:
+
+.. versionadded:: 1.0.5
+
+.. versionchanged:: 1.2.0
+
+    In the chooser template, the `controller` is no longer a direct reference
+    but a weak-reference. If you are upgrading, you should change the notation
+    `root.controller.xxx` to `root.controller().xxx`.
+
+'''
+
+__all__ = ('FileChooserListView', 'FileChooserIconView',
+           'FileChooserListLayout', 'FileChooserIconLayout',
+           'FileChooser', 'FileChooserController',
+           'FileChooserProgressBase', 'FileSystemAbstract',
+           'FileSystemLocal')
+
+from weakref import ref
+from time import time
+
+from kivy.core.text import DEFAULT_FONT
+from kivy.compat import string_types
+from kivy.factory import Factory
+from kivy.clock import Clock
+from kivy.lang import Builder
+from kivy.logger import Logger
+from kivy.utils import platform as core_platform
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.relativelayout import RelativeLayout
+from kivy.uix.screenmanager import ScreenManager, Screen
+from kivy.properties import (
+    StringProperty, ListProperty, BooleanProperty, ObjectProperty,
+    NumericProperty, AliasProperty)
+import collections.abc
+from os import listdir
+from os.path import (
+    basename, join, sep, normpath, expanduser, altsep,
+    splitdrive, realpath, getsize, isdir, abspath, isfile, dirname)
+from fnmatch import fnmatch
+
+platform = core_platform
+filesize_units = ('B', 'KB', 'MB', 'GB', 'TB')
+
+_have_win32file = False
+if platform == 'win':
+    # Import that module here as it's not available on non-windows machines.
+    # See http://bit.ly/i9klJE except that the attributes are defined in
+    # win32file not win32com (bug on page).
+    # Note: For some reason this doesn't work after a os.chdir(), no matter to
+    #       what directory you change from where. Windows weirdness.
+    try:
+        from win32file import FILE_ATTRIBUTE_HIDDEN, GetFileAttributesExW, \
+                              error
+        _have_win32file = True
+    except ImportError:
+        Logger.error('filechooser: win32file module is missing')
+        Logger.error('filechooser: we cannot check if a file is hidden or not')
+
+
+def alphanumeric_folders_first(files, filesystem):
+    return (sorted(f for f in files if filesystem.is_dir(f)) +
+            sorted(f for f in files if not filesystem.is_dir(f)))
+
+
+class FileSystemAbstract(object):
+    '''Class for implementing a File System view that can be used with the
+    :class:`FileChooser <FileChooser>`.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    def listdir(self, fn):
+        '''Return the list of files in the directory `fn`
+        '''
+        pass
+
+    def getsize(self, fn):
+        '''Return the size in bytes of a file
+        '''
+        pass
+
+    def is_hidden(self, fn):
+        '''Return True if the file is hidden
+        '''
+        pass
+
+    def is_dir(self, fn):
+        '''Return True if the argument passed to this method is a directory
+        '''
+        pass
+
+
+class FileSystemLocal(FileSystemAbstract):
+    '''Implementation of :class:`FileSystemAbstract` for local files.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    def listdir(self, fn):
+        return listdir(fn)
+
+    def getsize(self, fn):
+        return getsize(fn)
+
+    def is_hidden(self, fn):
+        if platform == 'win':
+            if not _have_win32file:
+                return False
+            try:
+                return GetFileAttributesExW(fn)[0] & FILE_ATTRIBUTE_HIDDEN
+            except error:
+                # This error can occurred when a file is already accessed by
+                # someone else. So don't return to True, because we have lot
+                # of chances to not being able to do anything with it.
+                Logger.exception('unable to access to <%s>' % fn)
+                return True
+
+        return basename(fn).startswith('.')
+
+    def is_dir(self, fn):
+        return isdir(fn)
+
+
+class FileChooserProgressBase(FloatLayout):
+    '''Base for implementing a progress view. This view is used when too many
+    entries need to be created and are delayed over multiple frames.
+
+    .. versionadded:: 1.2.0
+    '''
+
+    path = StringProperty('')
+    '''Current path of the FileChooser, read-only.
+    '''
+
+    index = NumericProperty(0)
+    '''Current index of :attr:`total` entries to be loaded.
+    '''
+
+    total = NumericProperty(1)
+    '''Total number of entries to load.
+    '''
+
+    def cancel(self, *largs):
+        '''Cancel any action from the FileChooserController.
+        '''
+        if self.parent:
+            self.parent.cancel()
+
+    def on_touch_down(self, touch):
+        if self.collide_point(*touch.pos):
+            super(FileChooserProgressBase, self).on_touch_down(touch)
+            return True
+
+    def on_touch_move(self, touch):
+        if self.collide_point(*touch.pos):
+            super(FileChooserProgressBase, self).on_touch_move(touch)
+            return True
+
+    def on_touch_up(self, touch):
+        if self.collide_point(*touch.pos):
+            super(FileChooserProgressBase, self).on_touch_up(touch)
+            return True
+
+
+class FileChooserProgress(FileChooserProgressBase):
+    pass
+
+
+class FileChooserLayout(FloatLayout):
+    '''Base class for file chooser layouts.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    VIEWNAME = 'undefined'
+
+    __events__ = ('on_entry_added', 'on_entries_cleared',
+                  'on_subentry_to_entry', 'on_remove_subentry', 'on_submit')
+
+    controller = ObjectProperty()
+    '''
+    Reference to the controller handling this layout.
+
+    :class:`~kivy.properties.ObjectProperty`
+    '''
+
+    def on_entry_added(self, node, parent=None):
+        pass
+
+    def on_entries_cleared(self):
+        pass
+
+    def on_subentry_to_entry(self, subentry, entry):
+        pass
+
+    def on_remove_subentry(self, subentry, entry):
+        pass
+
+    def on_submit(self, selected, touch=None):
+        pass
+
+
+class FileChooserListLayout(FileChooserLayout):
+    '''File chooser layout using a list view.
+
+    .. versionadded:: 1.9.0
+    '''
+    VIEWNAME = 'list'
+    _ENTRY_TEMPLATE = 'FileListEntry'
+
+    def __init__(self, **kwargs):
+        super(FileChooserListLayout, self).__init__(**kwargs)
+        self.fbind('on_entries_cleared', self.scroll_to_top)
+
+    def scroll_to_top(self, *args):
+        self.ids.scrollview.scroll_y = 1.0
+
+
+class FileChooserIconLayout(FileChooserLayout):
+    '''File chooser layout using an icon view.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    VIEWNAME = 'icon'
+    _ENTRY_TEMPLATE = 'FileIconEntry'
+
+    def __init__(self, **kwargs):
+        super(FileChooserIconLayout, self).__init__(**kwargs)
+        self.fbind('on_entries_cleared', self.scroll_to_top)
+
+    def scroll_to_top(self, *args):
+        self.ids.scrollview.scroll_y = 1.0
+
+
+class FileChooserController(RelativeLayout):
+    '''Base for implementing a FileChooser. Don't use this class directly, but
+    prefer using an implementation such as the :class:`FileChooser`,
+    :class:`FileChooserListView` or :class:`FileChooserIconView`.
+
+    :Events:
+        `on_entry_added`: entry, parent
+            Fired when a root-level entry is added to the file list. If you
+            return True from this event, the entry is not added to FileChooser.
+        `on_entries_cleared`
+            Fired when the the entries list is cleared, usually when the
+            root is refreshed.
+        `on_subentry_to_entry`: entry, parent
+            Fired when a sub-entry is added to an existing entry or
+            when entries are removed from an entry e.g. when
+            a node is closed.
+        `on_submit`: selection, touch
+            Fired when a file has been selected with a double-tap.
+    '''
+    _ENTRY_TEMPLATE = None
+
+    layout = ObjectProperty(baseclass=FileChooserLayout)
+    '''
+    Reference to the layout widget instance.
+
+    layout is an :class:`~kivy.properties.ObjectProperty`.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    path = StringProperty(u'/')
+    '''
+    path is a :class:`~kivy.properties.StringProperty` and defaults to the
+    current working directory as a unicode string. It specifies the path on the
+    filesystem that this controller should refer to.
+
+    .. warning::
+
+        If a unicode path is specified, all the files returned will be in
+        unicode, allowing the display of unicode files and paths. If a bytes
+        path is specified, only files and paths with ascii names will be
+        displayed properly: non-ascii filenames will be displayed and listed
+        with questions marks (?) instead of their unicode characters.
+    '''
+
+    filters = ListProperty([])
+    '''
+    filters specifies the filters to be applied to the files in the directory.
+    filters is a :class:`~kivy.properties.ListProperty` and defaults to [].
+    This is equivalent to '\\*' i.e. nothing is filtered.
+
+    The filters are not reset when the path changes. You need to do that
+    yourself if desired.
+
+    There are two kinds of filters: patterns and callbacks.
+
+    #. Patterns
+
+        e.g. ['\\*.png'].
+        You can use the following patterns:
+
+            ========== =================================
+            Pattern     Meaning
+            ========== =================================
+            \\*         matches everything
+            ?          matches any single character
+            [seq]      matches any character in seq
+            [!seq]     matches any character not in seq
+            ========== =================================
+
+    #. Callbacks
+
+        You can specify a function that will be called for each file. The
+        callback will be passed the folder and file name as the first
+        and second parameters respectively. It should return True to
+        indicate a match and False otherwise.
+
+    .. versionchanged:: 1.4.0
+        Added the option to specify the filter as a callback.
+    '''
+
+    filter_dirs = BooleanProperty(False)
+    '''
+    Indicates whether filters should also apply to directories.
+    filter_dirs is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    sort_func = ObjectProperty(alphanumeric_folders_first)
+    '''
+    Provides a function to be called with a list of filenames as the first
+    argument and the filesystem implementation as the second argument. It
+    returns a list of filenames sorted for display in the view.
+
+    sort_func is an :class:`~kivy.properties.ObjectProperty` and defaults to a
+    function returning alphanumerically named folders first.
+
+    .. versionchanged:: 1.8.0
+
+        The signature needs now 2 arguments: first the list of files,
+        second the filesystem class to use.
+    '''
+
+    files = ListProperty([])
+    '''
+    The list of files in the directory specified by path after applying the
+    filters.
+
+    files is a read-only :class:`~kivy.properties.ListProperty`.
+    '''
+
+    show_hidden = BooleanProperty(False)
+    '''
+    Determines whether hidden files and folders should be shown.
+
+    show_hidden is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    selection = ListProperty([])
+    '''
+    Contains the list of files that are currently selected.
+
+    selection is a read-only :class:`~kivy.properties.ListProperty` and
+    defaults to [].
+    '''
+
+    multiselect = BooleanProperty(False)
+    '''
+    Determines whether the user is able to select multiple files or not.
+
+    multiselect is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    dirselect = BooleanProperty(False)
+    '''
+    Determines whether directories are valid selections or not.
+
+    dirselect is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+
+    .. versionadded:: 1.1.0
+    '''
+
+    rootpath = StringProperty(None, allownone=True)
+    '''
+    Root path to use instead of the system root path. If set, it will not show
+    a ".." directory to go up to the root path. For example, if you set
+    rootpath to /users/foo, the user will be unable to go to /users or to any
+    other directory not starting with /users/foo.
+
+    rootpath is a :class:`~kivy.properties.StringProperty` and defaults
+    to None.
+
+    .. versionadded:: 1.2.0
+
+    .. note::
+
+        Similarly to :attr:`path`, whether `rootpath` is specified as
+        bytes or a unicode string determines the type of the filenames and
+        paths read.
+    '''
+
+    progress_cls = ObjectProperty(FileChooserProgress)
+    '''Class to use for displaying a progress indicator for filechooser
+    loading.
+
+    progress_cls is an :class:`~kivy.properties.ObjectProperty` and defaults to
+    :class:`FileChooserProgress`.
+
+    .. versionadded:: 1.2.0
+
+    .. versionchanged:: 1.8.0
+
+        If set to a string, the :class:`~kivy.factory.Factory` will be used to
+        resolve the class name.
+
+    '''
+
+    file_encodings = ListProperty(
+        ['utf-8', 'latin1', 'cp1252'], deprecated=True)
+    '''Possible encodings for decoding a filename to unicode. In the case that
+    the user has a non-ascii filename, undecodable without knowing its
+    initial encoding, we have no other choice than to guess it.
+
+    Please note that if you encounter an issue because of a missing encoding
+    here, we'll be glad to add it to this list.
+
+    file_encodings is a :class:`~kivy.properties.ListProperty` and defaults to
+    ['utf-8', 'latin1', 'cp1252'].
+
+    .. versionadded:: 1.3.0
+
+    .. deprecated:: 1.8.0
+       This property is no longer used as the filechooser no longer decodes
+       the file names.
+
+    '''
+
+    file_system = ObjectProperty(FileSystemLocal(),
+                                 baseclass=FileSystemAbstract)
+    '''The file system object used to access the file system. This should be a
+    subclass of :class:`FileSystemAbstract`.
+
+    file_system is an :class:`~kivy.properties.ObjectProperty` and defaults to
+    :class:`FileSystemLocal()`
+
+    .. versionadded:: 1.8.0
+    '''
+
+    font_name = StringProperty(DEFAULT_FONT)
+    '''Filename of the font to use in UI components. The path can be
+    absolute or relative.  Relative paths are resolved by the
+    :func:`~kivy.resources.resource_find` function.
+
+    :attr:`font_name` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'Roboto'. This value is taken
+    from :class:`~kivy.config.Config`.
+    '''
+
+    _update_files_ev = None
+    _create_files_entries_ev = None
+
+    __events__ = ('on_entry_added', 'on_entries_cleared',
+                  'on_subentry_to_entry', 'on_remove_subentry', 'on_submit')
+
+    def __init__(self, **kwargs):
+        self._progress = None
+        super(FileChooserController, self).__init__(**kwargs)
+
+        self._items = []
+        fbind = self.fbind
+        fbind('selection', self._update_item_selection)
+
+        self._previous_path = [self.path]
+        fbind('path', self._save_previous_path)
+        update = self._trigger_update
+        fbind('path', update)
+        fbind('filters', update)
+        fbind('rootpath', update)
+        update()
+
+    def on_touch_down(self, touch):
+        # don't respond to touchs outside self
+        if not self.collide_point(*touch.pos):
+            return
+        if self.disabled:
+            return True
+        return super(FileChooserController, self).on_touch_down(touch)
+
+    def on_touch_up(self, touch):
+        # don't respond to touchs outside self
+        if not self.collide_point(*touch.pos):
+            return
+        if self.disabled:
+            return True
+        return super(FileChooserController, self).on_touch_up(touch)
+
+    def _update_item_selection(self, *args):
+        for item in self._items:
+            item.selected = item.path in self.selection
+
+    def _save_previous_path(self, instance, value):
+        self._previous_path.append(value)
+        self._previous_path = self._previous_path[-2:]
+
+    def _trigger_update(self, *args):
+        ev = self._update_files_ev
+        if ev is None:
+            ev = self._update_files_ev = Clock.create_trigger(
+                self._update_files)
+        ev()
+
+    def on_entry_added(self, node, parent=None):
+        if self.layout:
+            self.layout.dispatch('on_entry_added', node, parent)
+
+    def on_entries_cleared(self):
+        if self.layout:
+            self.layout.dispatch('on_entries_cleared')
+
+    def on_subentry_to_entry(self, subentry, entry):
+        if self.layout:
+            self.layout.dispatch('on_subentry_to_entry', subentry, entry)
+
+    def on_remove_subentry(self, subentry, entry):
+        if self.layout:
+            self.layout.dispatch('on_remove_subentry', subentry, entry)
+
+    def on_submit(self, selected, touch=None):
+        if self.layout:
+            self.layout.dispatch('on_submit', selected, touch)
+
+    def entry_touched(self, entry, touch):
+        '''(internal) This method must be called by the template when an entry
+        is touched by the user.
+        '''
+        if (
+            'button' in touch.profile and touch.button in (
+                'scrollup', 'scrolldown', 'scrollleft', 'scrollright')):
+            return False
+
+        _dir = self.file_system.is_dir(entry.path)
+        dirselect = self.dirselect
+
+        if _dir and dirselect and touch.is_double_tap:
+            self.open_entry(entry)
+            return
+
+        if self.multiselect:
+            if entry.path in self.selection:
+                self.selection.remove(entry.path)
+            else:
+                if _dir and not self.dirselect:
+                    self.open_entry(entry)
+                    return
+                self.selection.append(entry.path)
+        else:
+            if _dir and not self.dirselect:
+                return
+            self.selection = [abspath(join(self.path, entry.path)), ]
+
+    def entry_released(self, entry, touch):
+        '''(internal) This method must be called by the template when an entry
+        is touched by the user.
+
+        .. versionadded:: 1.1.0
+        '''
+        if (
+            'button' in touch.profile and touch.button in (
+                'scrollup', 'scrolldown', 'scrollleft', 'scrollright')):
+            return False
+        if not self.multiselect:
+            if self.file_system.is_dir(entry.path) and not self.dirselect:
+                self.open_entry(entry)
+            elif touch.is_double_tap:
+                if self.dirselect and self.file_system.is_dir(entry.path):
+                    return
+                else:
+                    self.dispatch('on_submit', self.selection, touch)
+
+    def open_entry(self, entry):
+        try:
+            # Just check if we can list the directory. This is also what
+            # _add_file does, so if it fails here, it would also fail later
+            # on. Do the check here to prevent setting path to an invalid
+            # directory that we cannot list.
+            self.file_system.listdir(entry.path)
+        except OSError:
+            entry.locked = True
+        else:
+            # If entry.path is to jump to previous directory, update path with
+            # parent directory
+            self.path = abspath(join(self.path, entry.path))
+            self.selection = [self.path, ] if self.dirselect else []
+
+    def _apply_filters(self, files):
+        if not self.filters:
+            return files
+        filtered = []
+        for filt in self.filters:
+            if isinstance(filt, collections.abc.Callable):
+                filtered.extend([fn for fn in files if filt(self.path, fn)])
+            else:
+                filtered.extend([fn for fn in files if fnmatch(fn, filt)])
+        if not self.filter_dirs:
+            dirs = [fn for fn in files if self.file_system.is_dir(fn)]
+            filtered.extend(dirs)
+        return list(set(filtered))
+
+    def get_nice_size(self, fn):
+        '''Pass the filepath. Returns the size in the best human readable
+        format or '' if it is a directory (Don't recursively calculate size).
+        '''
+        if self.file_system.is_dir(fn):
+            return ''
+        try:
+            size = self.file_system.getsize(fn)
+        except OSError:
+            return '--'
+
+        for unit in filesize_units:
+            if size < 1024.0:
+                return '%1.0f %s' % (size, unit)
+            size /= 1024.0
+
+    def _update_files(self, *args, **kwargs):
+        # trigger to start gathering the files in the new directory
+        # we'll start a timer that will do the job, 10 times per frames
+        # (default)
+        self._gitems = []
+        self._gitems_parent = kwargs.get('parent', None)
+        self._gitems_gen = self._generate_file_entries(
+            path=kwargs.get('path', self.path),
+            parent=self._gitems_parent)
+        self.path = abspath(self.path)
+
+        # cancel any previous clock if exist
+        ev = self._create_files_entries_ev
+        if ev is not None:
+            ev.cancel()
+
+        # show the progression screen
+        self._hide_progress()
+        if self._create_files_entries():
+            # not enough for creating all the entries, all a clock to continue
+            # start a timer for the next 100 ms
+            if ev is None:
+                ev = self._create_files_entries_ev = Clock.schedule_interval(
+                    self._create_files_entries, .1)
+            ev()
+
+    def _get_file_paths(self, items):
+        return [file.path for file in items]
+
+    def _create_files_entries(self, *args):
+        # create maximum entries during 50ms max, or 10 minimum (slow system)
+        # (on a "fast system" (core i7 2700K), we can create up to 40 entries
+        # in 50 ms. So 10 is fine for low system.
+        start = time()
+        finished = False
+        index = total = count = 1
+        while time() - start < 0.05 or count < 10:
+            try:
+                index, total, item = next(self._gitems_gen)
+                self._gitems.append(item)
+                count += 1
+            except StopIteration:
+                finished = True
+                break
+            except TypeError:  # in case _gitems_gen is None
+                finished = True
+                break
+
+        # if this wasn't enough for creating all the entries, show a progress
+        # bar, and report the activity to the user.
+        if not finished:
+            self._show_progress()
+            self._progress.total = total
+            self._progress.index = index
+            return True
+
+        # we created all the files, now push them on the view
+        self._items = items = self._gitems
+        parent = self._gitems_parent
+        if parent is None:
+            self.dispatch('on_entries_cleared')
+            for entry in items:
+                self.dispatch('on_entry_added', entry, parent)
+        else:
+            parent.entries[:] = items
+            for entry in items:
+                self.dispatch('on_subentry_to_entry', entry, parent)
+        self.files[:] = self._get_file_paths(items)
+
+        # stop the progression / creation
+        self._hide_progress()
+        self._gitems = None
+        self._gitems_gen = None
+        ev = self._create_files_entries_ev
+        if ev is not None:
+            ev.cancel()
+        return False
+
+    def cancel(self, *largs):
+        '''Cancel any background action started by filechooser, such as loading
+        a new directory.
+
+        .. versionadded:: 1.2.0
+        '''
+        ev = self._create_files_entries_ev
+        if ev is not None:
+            ev.cancel()
+
+        self._hide_progress()
+        if len(self._previous_path) > 1:
+            # if we cancel any action, the path will be set same as the
+            # previous one, so we can safely cancel the update of the previous
+            # path.
+            self.path = self._previous_path[-2]
+
+            ev = self._update_files_ev
+            if ev is not None:
+                ev.cancel()
+
+    def _show_progress(self):
+        if self._progress:
+            return
+        cls = self.progress_cls
+        if isinstance(cls, string_types):
+            cls = Factory.get(cls)
+        self._progress = cls(path=self.path)
+        self._progress.value = 0
+        self.add_widget(self._progress)
+
+    def _hide_progress(self):
+        if self._progress:
+            self.remove_widget(self._progress)
+            self._progress = None
+
+    def _generate_file_entries(self, *args, **kwargs):
+        # Generator that will create all the files entries.
+        # the generator is used via _update_files() and _create_files_entries()
+        # don't use it directly.
+        is_root = False
+        path = kwargs.get('path', self.path)
+        have_parent = kwargs.get('parent', None) is not None
+
+        # Add the components that are always needed
+        if self.rootpath:
+            rootpath = realpath(self.rootpath)
+            path = realpath(path)
+            if not path.startswith(rootpath):
+                self.path = rootpath
+                return
+            elif path == rootpath:
+                is_root = True
+        else:
+            if platform == 'win':
+                is_root = splitdrive(path)[1] in (sep, altsep)
+            elif platform in ('macosx', 'linux', 'android', 'ios'):
+                is_root = normpath(expanduser(path)) == sep
+            else:
+                # Unknown fs, just always add the .. entry but also log
+                Logger.warning('Filechooser: Unsupported OS: %r' % platform)
+        # generate an entries to go back to previous
+        if not is_root and not have_parent:
+            back = '..' + sep
+            if platform == 'win':
+                new_path = path[:path.rfind(sep)]
+                if sep not in new_path:
+                    new_path += sep
+                pardir = self._create_entry_widget(dict(
+                    name=back, size='', path=new_path, controller=ref(self),
+                    isdir=True, parent=None, sep=sep,
+                    get_nice_size=lambda: ''))
+            else:
+                pardir = self._create_entry_widget(dict(
+                    name=back, size='', path=back, controller=ref(self),
+                    isdir=True, parent=None, sep=sep,
+                    get_nice_size=lambda: ''))
+            yield 0, 1, pardir
+
+        # generate all the entries for files
+        try:
+            for index, total, item in self._add_files(path):
+                yield index, total, item
+        except OSError:
+            Logger.exception('Unable to open directory <%s>' % self.path)
+            self.files[:] = []
+
+    def _create_entry_widget(self, ctx):
+        template = self.layout._ENTRY_TEMPLATE\
+            if self.layout else self._ENTRY_TEMPLATE
+        return Builder.template(template, **ctx)
+
+    def _add_files(self, path, parent=None):
+        path = expanduser(path)
+        if isfile(path):
+            path = dirname(path)
+
+        files = []
+        fappend = files.append
+        for f in self.file_system.listdir(path):
+            try:
+                # In the following, use fully qualified filenames
+                fappend(normpath(join(path, f)))
+            except UnicodeDecodeError:
+                Logger.exception('unable to decode <{}>'.format(f))
+            except UnicodeEncodeError:
+                Logger.exception('unable to encode <{}>'.format(f))
+        # Apply filename filters
+        files = self._apply_filters(files)
+        # Sort the list of files
+        files = self.sort_func(files, self.file_system)
+        is_hidden = self.file_system.is_hidden
+        if not self.show_hidden:
+            files = [x for x in files if not is_hidden(x)]
+        self.files[:] = files
+        total = len(files)
+        wself = ref(self)
+        for index, fn in enumerate(files):
+
+            def get_nice_size():
+                # Use a closure for lazy-loading here
+                return self.get_nice_size(fn)
+
+            ctx = {'name': basename(fn),
+                   'get_nice_size': get_nice_size,
+                   'path': fn,
+                   'controller': wself,
+                   'isdir': self.file_system.is_dir(fn),
+                   'parent': parent,
+                   'sep': sep}
+            entry = self._create_entry_widget(ctx)
+            yield index, total, entry
+
+    def entry_subselect(self, entry):
+        if not self.file_system.is_dir(entry.path):
+            return
+        self._update_files(path=entry.path, parent=entry)
+
+    def close_subselection(self, entry):
+        for subentry in entry.entries:
+            self.dispatch('on_remove_subentry', subentry, entry)
+
+
+class FileChooserListView(FileChooserController):
+    '''Implementation of a :class:`FileChooserController` using a list view.
+
+    .. versionadded:: 1.9.0
+    '''
+    _ENTRY_TEMPLATE = 'FileListEntry'
+
+
+class FileChooserIconView(FileChooserController):
+    '''Implementation of a :class:`FileChooserController` using an icon view.
+
+    .. versionadded:: 1.9.0
+    '''
+    _ENTRY_TEMPLATE = 'FileIconEntry'
+
+
+class FileChooser(FileChooserController):
+    '''Implementation of a :class:`FileChooserController` which supports
+    switching between multiple, synced layout views.
+
+    The FileChooser can be used as follows:
+
+    .. code-block:: kv
+
+        BoxLayout:
+            orientation: 'vertical'
+
+            BoxLayout:
+                size_hint_y: None
+                height: sp(52)
+
+                Button:
+                    text: 'Icon View'
+                    on_press: fc.view_mode = 'icon'
+                Button:
+                    text: 'List View'
+                    on_press: fc.view_mode = 'list'
+
+            FileChooser:
+                id: fc
+                FileChooserIconLayout
+                FileChooserListLayout
+
+    .. versionadded:: 1.9.0
+    '''
+
+    manager = ObjectProperty()
+    '''
+    Reference to the :class:`~kivy.uix.screenmanager.ScreenManager` instance.
+
+    manager is an :class:`~kivy.properties.ObjectProperty`.
+    '''
+
+    _view_list = ListProperty()
+
+    def get_view_list(self):
+        return self._view_list
+
+    view_list = AliasProperty(get_view_list, bind=('_view_list',))
+    '''
+    List of views added to this FileChooser.
+
+    view_list is an :class:`~kivy.properties.AliasProperty` of type
+    :class:`list`.
+    '''
+
+    _view_mode = StringProperty()
+
+    def get_view_mode(self):
+        return self._view_mode
+
+    def set_view_mode(self, mode):
+        if mode not in self._view_list:
+            raise ValueError('unknown view mode %r' % mode)
+        self._view_mode = mode
+
+    view_mode = AliasProperty(
+        get_view_mode, set_view_mode, bind=('_view_mode',))
+    '''
+    Current layout view mode.
+
+    view_mode is an :class:`~kivy.properties.AliasProperty` of type
+    :class:`str`.
+    '''
+
+    @property
+    def _views(self):
+        return [screen.children[0] for screen in self.manager.screens]
+
+    def __init__(self, **kwargs):
+        super(FileChooser, self).__init__(**kwargs)
+
+        self.manager = ScreenManager()
+        super(FileChooser, self).add_widget(self.manager)
+
+        self.trigger_update_view = Clock.create_trigger(self.update_view)
+
+        self.fbind('view_mode', self.trigger_update_view)
+
+    def add_widget(self, widget, *args, **kwargs):
+        if widget is self._progress:
+            super(FileChooser, self).add_widget(widget, *args, **kwargs)
+        elif hasattr(widget, 'VIEWNAME'):
+            name = widget.VIEWNAME + 'view'
+            screen = Screen(name=name)
+            widget.controller = self
+            screen.add_widget(widget)
+            self.manager.add_widget(screen)
+
+            self.trigger_update_view()
+        else:
+            raise ValueError(
+                'widget must be a FileChooserLayout,'
+                ' not %s' % type(widget).__name__)
+
+    def rebuild_views(self):
+        views = [view.VIEWNAME for view in self._views]
+        if views != self._view_list:
+            self._view_list = views
+            if self._view_mode not in self._view_list:
+                self._view_mode = self._view_list[0]
+            self._trigger_update()
+
+    def update_view(self, *args):
+        self.rebuild_views()
+
+        sm = self.manager
+        viewlist = self._view_list
+        view = self.view_mode
+        current = sm.current[:-4]
+
+        viewindex = viewlist.index(view) if view in viewlist else 0
+        currentindex = viewlist.index(current) if current in viewlist else 0
+
+        direction = 'left' if currentindex < viewindex else 'right'
+
+        sm.transition.direction = direction
+        sm.current = view + 'view'
+
+    def _create_entry_widget(self, ctx):
+        return [Builder.template(view._ENTRY_TEMPLATE, **ctx)
+                for view in self._views]
+
+    def _get_file_paths(self, items):
+        if self._views:
+            return [file[0].path for file in items]
+        return []
+
+    def _update_item_selection(self, *args):
+        for viewitem in self._items:
+            selected = viewitem[0].path in self.selection
+            for item in viewitem:
+                item.selected = selected
+
+    def on_entry_added(self, node, parent=None):
+        for index, view in enumerate(self._views):
+            view.dispatch(
+                'on_entry_added',
+                node[index], parent[index] if parent else None)
+
+    def on_entries_cleared(self):
+        for view in self._views:
+            view.dispatch('on_entries_cleared')
+
+    def on_subentry_to_entry(self, subentry, entry):
+        for index, view in enumerate(self._views):
+            view.dispatch('on_subentry_to_entry', subentry[index], entry)
+
+    def on_remove_subentry(self, subentry, entry):
+        for index, view in enumerate(self._views):
+            view.dispatch('on_remove_subentry', subentry[index], entry)
+
+    def on_submit(self, selected, touch=None):
+        view_mode = self.view_mode
+        for view in self._views:
+            if view_mode == view.VIEWNAME:
+                view.dispatch('on_submit', selected, touch)
+                return
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+    from pprint import pprint
+    import textwrap
+    import sys
+
+    root = Builder.load_string(textwrap.dedent('''\
+    BoxLayout:
+        orientation: 'vertical'
+
+        BoxLayout:
+            size_hint_y: None
+            height: sp(52)
+
+            Button:
+                text: 'Icon View'
+                on_press: fc.view_mode = 'icon'
+            Button:
+                text: 'List View'
+                on_press: fc.view_mode = 'list'
+
+        FileChooser:
+            id: fc
+
+            FileChooserIconLayout
+            FileChooserListLayout
+    '''))
+
+    class FileChooserApp(App):
+
+        def build(self):
+            v = root.ids.fc
+            if len(sys.argv) > 1:
+                v.path = sys.argv[1]
+
+            v.bind(selection=lambda *x: pprint("selection: %s" % x[1:]))
+            v.bind(path=lambda *x: pprint("path: %s" % x[1:]))
+
+            return root
+
+    FileChooserApp().run()
diff --git a/kivy/uix/floatlayout.py b/kivy/uix/floatlayout.py
new file mode 100644
index 0000000..73b5858
--- /dev/null
+++ b/kivy/uix/floatlayout.py
@@ -0,0 +1,148 @@
+'''
+Float Layout
+============
+
+:class:`FloatLayout` honors the :attr:`~kivy.uix.widget.Widget.pos_hint`
+and the :attr:`~kivy.uix.widget.Widget.size_hint` properties of its children.
+
+.. only:: html
+
+    .. image:: images/floatlayout.gif
+        :align: right
+
+.. only:: latex
+
+    .. image:: images/floatlayout.png
+        :align: right
+
+For example, a FloatLayout with a size of (300, 300) is created::
+
+    layout = FloatLayout(size=(300, 300))
+
+By default, all widgets have their size_hint=(1, 1), so this button will adopt
+the same size as the layout::
+
+    button = Button(text='Hello world')
+    layout.add_widget(button)
+
+To create a button 50% of the width and 25% of the height of the layout and
+positioned at (20, 20), you can do::
+
+    button = Button(
+        text='Hello world',
+        size_hint=(.5, .25),
+        pos=(20, 20))
+
+If you want to create a button that will always be the size of layout minus
+20% on each side::
+
+    button = Button(text='Hello world', size_hint=(.6, .6),
+                    pos_hint={'x':.2, 'y':.2})
+
+.. note::
+
+    This layout can be used for an application. Most of the time, you will
+    use the size of Window.
+
+.. warning::
+
+    If you are not using pos_hint, you must handle the positioning of the
+    children: if the float layout is moving, you must handle moving the
+    children too.
+
+'''
+
+__all__ = ('FloatLayout', )
+
+from kivy.uix.layout import Layout
+
+
+class FloatLayout(Layout):
+    '''Float layout class. See module documentation for more information.
+    '''
+
+    def __init__(self, **kwargs):
+        super(FloatLayout, self).__init__(**kwargs)
+        fbind = self.fbind
+        update = self._trigger_layout
+        fbind('children', update)
+        fbind('pos', update)
+        fbind('pos_hint', update)
+        fbind('size_hint', update)
+        fbind('size', update)
+
+    def do_layout(self, *largs, **kwargs):
+        # optimize layout by preventing looking at the same attribute in a loop
+        w, h = kwargs.get('size', self.size)
+        x, y = kwargs.get('pos', self.pos)
+        for c in self.children:
+            # size
+            shw, shh = c.size_hint
+            shw_min, shh_min = c.size_hint_min
+            shw_max, shh_max = c.size_hint_max
+
+            if shw is not None and shh is not None:
+                c_w = shw * w
+                c_h = shh * h
+
+                if shw_min is not None and c_w < shw_min:
+                    c_w = shw_min
+                elif shw_max is not None and c_w > shw_max:
+                    c_w = shw_max
+
+                if shh_min is not None and c_h < shh_min:
+                    c_h = shh_min
+                elif shh_max is not None and c_h > shh_max:
+                    c_h = shh_max
+                c.size = c_w, c_h
+            elif shw is not None:
+                c_w = shw * w
+
+                if shw_min is not None and c_w < shw_min:
+                    c_w = shw_min
+                elif shw_max is not None and c_w > shw_max:
+                    c_w = shw_max
+                c.width = c_w
+            elif shh is not None:
+                c_h = shh * h
+
+                if shh_min is not None and c_h < shh_min:
+                    c_h = shh_min
+                elif shh_max is not None and c_h > shh_max:
+                    c_h = shh_max
+                c.height = c_h
+
+            # pos
+            for key, value in c.pos_hint.items():
+                if key == 'x':
+                    c.x = x + value * w
+                elif key == 'right':
+                    c.right = x + value * w
+                elif key == 'pos':
+                    c.pos = x + value[0] * w, y + value[1] * h
+                elif key == 'y':
+                    c.y = y + value * h
+                elif key == 'top':
+                    c.top = y + value * h
+                elif key == 'center':
+                    c.center = x + value[0] * w, y + value[1] * h
+                elif key == 'center_x':
+                    c.center_x = x + value * w
+                elif key == 'center_y':
+                    c.center_y = y + value * h
+
+    def add_widget(self, widget, *args, **kwargs):
+        widget.bind(
+            # size=self._trigger_layout,
+            # size_hint=self._trigger_layout,
+            pos=self._trigger_layout,
+            pos_hint=self._trigger_layout)
+        return super(FloatLayout, self).add_widget(widget, *args, **kwargs)
+
+    def remove_widget(self, widget, *args, **kwargs):
+        widget.unbind(
+            # size=self._trigger_layout,
+            # size_hint=self._trigger_layout,
+            pos=self._trigger_layout,
+            pos_hint=self._trigger_layout)
+        return super(FloatLayout, self).remove_widget(widget, *args, **kwargs)
diff --git a/kivy/uix/gesturesurface.py b/kivy/uix/gesturesurface.py
new file mode 100644
index 0000000..3f7713e
--- /dev/null
+++ b/kivy/uix/gesturesurface.py
@@ -0,0 +1,625 @@
+'''
+Gesture Surface
+===============
+
+.. versionadded::
+    1.9.0
+
+.. warning::
+
+    This is experimental and subject to change as long as this warning notice
+    is present.
+
+See :file:`kivy/examples/demo/multistroke/main.py` for a complete application
+example.
+'''
+__all__ = ('GestureSurface', 'GestureContainer')
+
+from random import random
+from kivy.event import EventDispatcher
+from kivy.clock import Clock
+from kivy.vector import Vector
+from kivy.uix.floatlayout import FloatLayout
+from kivy.graphics import Color, Line, Rectangle
+from kivy.properties import (NumericProperty, BooleanProperty,
+                             DictProperty, ColorProperty)
+from colorsys import hsv_to_rgb
+
+# Clock undershoot margin, FIXME: this is probably too high?
+UNDERSHOOT_MARGIN = 0.1
+
+
+class GestureContainer(EventDispatcher):
+    '''Container object that stores information about a gesture. It has
+    various properties that are updated by `GestureSurface` as drawing
+    progresses.
+
+    :Arguments:
+        `touch`
+            Touch object (as received by on_touch_down) used to initialize
+            the gesture container. Required.
+
+    :Properties:
+        `active`
+            Set to False once the gesture is complete (meets
+            `max_stroke` setting or `GestureSurface.temporal_window`)
+
+            :attr:`active` is a
+            :class:`~kivy.properties.BooleanProperty`
+
+        `active_strokes`
+            Number of strokes currently active in the gesture, ie
+            concurrent touches associated with this gesture.
+
+            :attr:`active_strokes` is a
+            :class:`~kivy.properties.NumericProperty`
+
+        `max_strokes`
+            Max number of strokes allowed in the gesture. This
+            is set by `GestureSurface.max_strokes` but can
+            be overridden for example from `on_gesture_start`.
+
+            :attr:`max_strokes` is a
+            :class:`~kivy.properties.NumericProperty`
+
+        `was_merged`
+            Indicates that this gesture has been merged with another
+            gesture and should be considered discarded.
+
+            :attr:`was_merged` is a
+            :class:`~kivy.properties.BooleanProperty`
+
+        `bbox`
+            Dictionary with keys minx, miny, maxx, maxy. Represents the size
+            of the gesture bounding box.
+
+            :attr:`bbox` is a
+            :class:`~kivy.properties.DictProperty`
+
+        `width`
+            Represents the width of the gesture.
+
+            :attr:`width` is a
+            :class:`~kivy.properties.NumericProperty`
+
+        `height`
+            Represents the height of the gesture.
+
+            :attr:`height` is a
+            :class:`~kivy.properties.NumericProperty`
+    '''
+    active = BooleanProperty(True)
+    active_strokes = NumericProperty(0)
+    max_strokes = NumericProperty(0)
+    was_merged = BooleanProperty(False)
+    bbox = DictProperty({'minx': float('inf'), 'miny': float('inf'),
+                         'maxx': float('-inf'), 'maxy': float('-inf')})
+    width = NumericProperty(0)
+    height = NumericProperty(0)
+
+    def __init__(self, touch, **kwargs):
+        # The color is applied to all canvas items of this gesture
+        self.color = kwargs.pop('color', [1., 1., 1.])
+
+        super(GestureContainer, self).__init__(**kwargs)
+
+        # This is the touch.uid of the oldest touch represented
+        self.id = str(touch.uid)
+
+        # Store various timestamps for decision making
+        self._create_time = Clock.get_time()
+        self._update_time = None
+        self._cleanup_time = None
+        self._cache_time = 0
+
+        # We can cache the candidate here to save zip()/Vector instantiation
+        self._vectors = None
+
+        # Key is touch.uid; value is a kivy.graphics.Line(); it's used even
+        # if line_width is 0 (i.e. not actually drawn anywhere)
+        self._strokes = {}
+
+        # Make sure the bbox is up to date with the first touch position
+        self.update_bbox(touch)
+
+    def get_vectors(self, **kwargs):
+        '''Return strokes in a format that is acceptable for
+        `kivy.multistroke.Recognizer` as a gesture candidate or template. The
+        result is cached automatically; the cache is invalidated at the start
+        and end of a stroke and if `update_bbox` is called. If you are going
+        to analyze a gesture mid-stroke, you may need to set the `no_cache`
+        argument to True.'''
+        if self._cache_time == self._update_time and \
+                not kwargs.get('no_cache'):
+            return self._vectors
+
+        vecs = []
+        append = vecs.append
+        for tuid, l in self._strokes.items():
+            lpts = l.points
+            append([Vector(*pts) for pts in zip(lpts[::2], lpts[1::2])])
+
+        self._vectors = vecs
+        self._cache_time = self._update_time
+        return vecs
+
+    def handles(self, touch):
+        '''Returns True if this container handles the given touch'''
+        if not self.active:
+            return False
+        return str(touch.uid) in self._strokes
+
+    def accept_stroke(self, count=1):
+        '''Returns True if this container can accept `count` new strokes'''
+        if not self.max_strokes:
+            return True
+        return len(self._strokes) + count <= self.max_strokes
+
+    def update_bbox(self, touch):
+        '''Update gesture bbox from a touch coordinate'''
+        x, y = touch.x, touch.y
+        bb = self.bbox
+        if x < bb['minx']:
+            bb['minx'] = x
+        if y < bb['miny']:
+            bb['miny'] = y
+        if x > bb['maxx']:
+            bb['maxx'] = x
+        if y > bb['maxy']:
+            bb['maxy'] = y
+        self.width = bb['maxx'] - bb['minx']
+        self.height = bb['maxy'] - bb['miny']
+        self._update_time = Clock.get_time()
+
+    def add_stroke(self, touch, line):
+        '''Associate a list of points with a touch.uid; the line itself is
+        created by the caller, but subsequent move/up events look it
+        up via us. This is done to avoid problems during merge.'''
+        self._update_time = Clock.get_time()
+        self._strokes[str(touch.uid)] = line
+        self.active_strokes += 1
+
+    def complete_stroke(self):
+        '''Called on touch up events to keep track of how many strokes
+        are active in the gesture (we only want to dispatch event when
+        the *last* stroke in the gesture is released)'''
+        self._update_time = Clock.get_time()
+        self.active_strokes -= 1
+
+    def single_points_test(self):
+        '''Returns True if the gesture consists only of single-point strokes,
+        we must discard it in this case, or an exception will be raised'''
+        for tuid, l in self._strokes.items():
+            if len(l.points) > 2:
+                return False
+        return True
+
+
+class GestureSurface(FloatLayout):
+    '''Simple gesture surface to track/draw touch movements. Typically used
+    to gather user input suitable for :class:`kivy.multistroke.Recognizer`.
+
+    :Properties:
+        `temporal_window`
+            Time to wait from the last touch_up event before attempting
+            to recognize the gesture. If you set this to 0, the
+            `on_gesture_complete` event is not fired unless the
+            :attr:`max_strokes` condition is met.
+
+            :attr:`temporal_window` is a
+            :class:`~kivy.properties.NumericProperty` and defaults to 2.0
+
+        `max_strokes`
+            Max number of strokes in a single gesture; if this is reached,
+            recognition will start immediately on the final touch_up event.
+            If this is set to 0, the `on_gesture_complete` event is not
+            fired unless the :attr:`temporal_window` expires.
+
+            :attr:`max_strokes` is a
+            :class:`~kivy.properties.NumericProperty` and defaults to 2.0
+
+        `bbox_margin`
+            Bounding box margin for detecting gesture collisions, in
+            pixels.
+
+            :attr:`bbox_margin` is a
+            :class:`~kivy.properties.NumericProperty` and defaults to 30
+
+        `draw_timeout`
+            Number of seconds to keep lines/bbox on canvas after the
+            `on_gesture_complete` event is fired. If this is set to 0,
+            gestures are immediately removed from the surface when
+            complete.
+
+            :attr:`draw_timeout` is a
+            :class:`~kivy.properties.NumericProperty` and defaults to 3.0
+
+        `color`
+            Color used to draw the gesture, in RGB. This option does not
+            have an effect if :attr:`use_random_color` is True.
+
+            :attr:`color` is a
+            :class:`~kivy.properties.ColorProperty` and defaults to
+            [1, 1, 1, 1] (white)
+
+            .. versionchanged:: 2.0.0
+                Changed from :class:`~kivy.properties.ListProperty` to
+                :class:`~kivy.properties.ColorProperty`.
+
+        `use_random_color`
+            Set to True to pick a random color for each gesture, if you do
+            this then `color` is ignored. Defaults to False.
+
+            :attr:`use_random_color` is a
+            :class:`~kivy.properties.BooleanProperty` and defaults to False
+
+        `line_width`
+            Line width used for tracing touches on the surface. Set to 0
+            if you only want to detect gestures without drawing anything.
+            If you use 1.0, OpenGL GL_LINE is used for drawing; values > 1
+            will use an internal drawing method based on triangles (less
+            efficient), see :mod:`kivy.graphics`.
+
+            :attr:`line_width` is a
+            :class:`~kivy.properties.NumericProperty` and defaults to 2
+
+        `draw_bbox`
+            Set to True if you want to draw bounding box behind gestures.
+            This only works if `line_width` >= 1. Default is False.
+
+            :attr:`draw_bbox` is a
+            :class:`~kivy.properties.BooleanProperty` and defaults to True
+
+        `bbox_alpha`
+            Opacity for bounding box if `draw_bbox` is True. Default 0.1
+
+            :attr:`bbox_alpha` is a
+            :class:`~kivy.properties.NumericProperty` and defaults to 0.1
+
+    :Events:
+        `on_gesture_start` :class:`GestureContainer`
+            Fired when a new gesture is initiated on the surface, i.e. the
+            first on_touch_down that does not collide with an existing
+            gesture on the surface.
+
+        `on_gesture_extend` :class:`GestureContainer`
+            Fired when a touch_down event occurs within an existing gesture.
+
+        `on_gesture_merge` :class:`GestureContainer`, :class:`GestureContainer`
+            Fired when two gestures collide and get merged to one gesture.
+            The first argument is the gesture that has been merged (no longer
+            valid); the second is the combined (resulting) gesture.
+
+        `on_gesture_complete` :class:`GestureContainer`
+            Fired when a set of strokes is considered a complete gesture,
+            this happens when `temporal_window` expires or `max_strokes`
+            is reached. Typically you will bind to this event and use
+            the provided `GestureContainer` get_vectors() method to
+            match against your gesture database.
+
+        `on_gesture_cleanup` :class:`GestureContainer`
+            Fired `draw_timeout` seconds after `on_gesture_complete`,
+            The gesture will be removed from the canvas (if line_width > 0 or
+            draw_bbox is True) and the internal gesture list before this.
+
+        `on_gesture_discard` :class:`GestureContainer`
+            Fired when a gesture does not meet the minimum size requirements
+            for recognition (width/height < 5, or consists only of single-
+            point strokes).
+    '''
+
+    temporal_window = NumericProperty(2.0)
+    draw_timeout = NumericProperty(3.0)
+    max_strokes = NumericProperty(4)
+    bbox_margin = NumericProperty(30)
+
+    line_width = NumericProperty(2)
+    color = ColorProperty([1., 1., 1., 1.])
+    use_random_color = BooleanProperty(False)
+    draw_bbox = BooleanProperty(False)
+    bbox_alpha = NumericProperty(0.1)
+
+    def __init__(self, **kwargs):
+        super(GestureSurface, self).__init__(**kwargs)
+        # A list of GestureContainer objects (all gestures on the surface)
+        self._gestures = []
+        self.register_event_type('on_gesture_start')
+        self.register_event_type('on_gesture_extend')
+        self.register_event_type('on_gesture_merge')
+        self.register_event_type('on_gesture_complete')
+        self.register_event_type('on_gesture_cleanup')
+        self.register_event_type('on_gesture_discard')
+
+# -----------------------------------------------------------------------------
+# Touch Events
+# -----------------------------------------------------------------------------
+    def on_touch_down(self, touch):
+        '''When a new touch is registered, the first thing we do is to test if
+        it collides with the bounding box of another known gesture. If so, it
+        is assumed to be part of that gesture.
+        '''
+        # If the touch originates outside the surface, ignore it.
+        if not self.collide_point(touch.x, touch.y):
+            return
+
+        touch.grab(self)
+
+        # Add the stroke to existing gesture, or make a new one
+        g = self.find_colliding_gesture(touch)
+        new = False
+        if g is None:
+            g = self.init_gesture(touch)
+            new = True
+
+        # We now belong to a gesture (new or old); start a new stroke.
+        self.init_stroke(g, touch)
+
+        if new:
+            self.dispatch('on_gesture_start', g, touch)
+        else:
+            self.dispatch('on_gesture_extend', g, touch)
+
+        return True
+
+    def on_touch_move(self, touch):
+        '''When a touch moves, we add a point to the line on the canvas so the
+        path is updated. We must also check if the new point collides with the
+        bounding box of another gesture - if so, they should be merged.'''
+        if touch.grab_current is not self:
+            return
+        if not self.collide_point(touch.x, touch.y):
+            return
+
+        # Retrieve the GestureContainer object that handles this touch, and
+        # test for colliding gestures. If found, merge them to one.
+        g = self.get_gesture(touch)
+        collision = self.find_colliding_gesture(touch)
+        if collision is not None and g.accept_stroke(len(collision._strokes)):
+            merge = self.merge_gestures(g, collision)
+            if g.was_merged:
+                self.dispatch('on_gesture_merge', g, collision)
+            else:
+                self.dispatch('on_gesture_merge', collision, g)
+            g = merge
+        else:
+            g.update_bbox(touch)
+
+        # Add the new point to gesture stroke list and update the canvas line
+        g._strokes[str(touch.uid)].points += (touch.x, touch.y)
+
+        # Draw the gesture bounding box; if it is a single press that
+        # does not trigger a move event, we would miss it otherwise.
+        if self.draw_bbox:
+            self._update_canvas_bbox(g)
+        return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+
+        g = self.get_gesture(touch)
+        g.complete_stroke()
+
+        # If this stroke hit the maximum limit, dispatch immediately
+        if not g.accept_stroke():
+            self._complete_dispatcher(0)
+
+        # dispatch later only if we have a window
+        elif self.temporal_window > 0:
+            Clock.schedule_once(self._complete_dispatcher,
+                                    self.temporal_window)
+
+# -----------------------------------------------------------------------------
+# Gesture related methods
+# -----------------------------------------------------------------------------
+    def init_gesture(self, touch):
+        '''Create a new gesture from touch, i.e. it's the first on
+        surface, or was not close enough to any existing gesture (yet)'''
+        col = self.color
+        if self.use_random_color:
+            col = hsv_to_rgb(random(), 1., 1.)
+
+        g = GestureContainer(touch, max_strokes=self.max_strokes, color=col)
+
+        # Create the bounding box Rectangle for the gesture
+        if self.draw_bbox:
+            bb = g.bbox
+            with self.canvas:
+                Color(col[0], col[1], col[2], self.bbox_alpha, mode='rgba',
+                      group=g.id)
+
+                g._bbrect = Rectangle(
+                    group=g.id,
+                    pos=(bb['minx'], bb['miny']),
+                    size=(bb['maxx'] - bb['minx'],
+                          bb['maxy'] - bb['miny']))
+
+        self._gestures.append(g)
+        return g
+
+    def init_stroke(self, g, touch):
+        points = [touch.x, touch.y]
+        col = g.color
+
+        new_line = Line(
+            points=points,
+            width=self.line_width,
+            group=g.id)
+        g._strokes[str(touch.uid)] = new_line
+
+        if self.line_width:
+            canvas_add = self.canvas.add
+            canvas_add(Color(col[0], col[1], col[2], mode='rgb', group=g.id))
+            canvas_add(new_line)
+
+        # Update the bbox in case; this will normally be done in on_touch_move,
+        # but we want to update it also for a single press, force that here:
+        g.update_bbox(touch)
+        if self.draw_bbox:
+            self._update_canvas_bbox(g)
+
+        # Register the stroke in GestureContainer so we can look it up later
+        g.add_stroke(touch, new_line)
+
+    def get_gesture(self, touch):
+        '''Returns GestureContainer associated with given touch'''
+        for g in self._gestures:
+            if g.active and g.handles(touch):
+                return g
+        raise Exception('get_gesture() failed to identify ' + str(touch.uid))
+
+    def find_colliding_gesture(self, touch):
+        '''Checks if a touch x/y collides with the bounding box of an existing
+        gesture. If so, return it (otherwise returns None)
+        '''
+        touch_x, touch_y = touch.pos
+        for g in self._gestures:
+            if g.active and not g.handles(touch) and g.accept_stroke():
+                bb = g.bbox
+                margin = self.bbox_margin
+                minx = bb['minx'] - margin
+                miny = bb['miny'] - margin
+                maxx = bb['maxx'] + margin
+                maxy = bb['maxy'] + margin
+                if minx <= touch_x <= maxx and miny <= touch_y <= maxy:
+                    return g
+        return None
+
+    def merge_gestures(self, g, other):
+        '''Merges two gestures together, the oldest one is retained and the
+        newer one gets the `GestureContainer.was_merged` flag raised.'''
+        # Swap order depending on gesture age (the merged gesture gets
+        # the color from the oldest one of the two).
+        swap = other._create_time < g._create_time
+        a = swap and other or g
+        b = swap and g or other
+
+        # Apply the outer limits of bbox to the merged gesture
+        abbox = a.bbox
+        bbbox = b.bbox
+        if bbbox['minx'] < abbox['minx']:
+            abbox['minx'] = bbbox['minx']
+        if bbbox['miny'] < abbox['miny']:
+            abbox['miny'] = bbbox['miny']
+        if bbbox['maxx'] > abbox['maxx']:
+            abbox['maxx'] = bbbox['maxx']
+        if bbbox['maxy'] > abbox['maxy']:
+            abbox['maxy'] = bbbox['maxy']
+
+        # Now transfer the coordinates from old to new gesture;
+        # FIXME: This can probably be copied more efficiently?
+        astrokes = a._strokes
+        lw = self.line_width
+        a_id = a.id
+        col = a.color
+
+        self.canvas.remove_group(b.id)
+        canv_add = self.canvas.add
+        for uid, old in b._strokes.items():
+            # FIXME: Can't figure out how to change group= for existing Line()
+            new_line = Line(
+                points=old.points,
+                width=old.width,
+                group=a_id)
+            astrokes[uid] = new_line
+            if lw:
+                canv_add(Color(col[0], col[1], col[2], mode='rgb', group=a_id))
+                canv_add(new_line)
+
+        b.active = False
+        b.was_merged = True
+        a.active_strokes += b.active_strokes
+        a._update_time = Clock.get_time()
+        return a
+
+    def _update_canvas_bbox(self, g):
+        # If draw_bbox is changed while two gestures are active,
+        # we might not have a bbrect member
+        if not hasattr(g, '_bbrect'):
+            return
+
+        bb = g.bbox
+        g._bbrect.pos = (bb['minx'], bb['miny'])
+        g._bbrect.size = (bb['maxx'] - bb['minx'],
+                          bb['maxy'] - bb['miny'])
+
+# -----------------------------------------------------------------------------
+# Timeout callbacks
+# -----------------------------------------------------------------------------
+    def _complete_dispatcher(self, dt):
+        '''This method is scheduled on all touch up events. It will dispatch
+        the `on_gesture_complete` event for all completed gestures, and remove
+        merged gestures from the internal gesture list.'''
+        need_cleanup = False
+        gest = self._gestures
+        timeout = self.draw_timeout
+        twin = self.temporal_window
+        get_time = Clock.get_time
+
+        for idx, g in enumerate(gest):
+            # Gesture is part of another gesture, just delete it
+            if g.was_merged:
+                del gest[idx]
+                continue
+
+            # Not active == already handled, or has active strokes (it cannot
+            # possibly be complete). Proceed to next gesture on surface.
+            if not g.active or g.active_strokes != 0:
+                continue
+
+            t1 = g._update_time + twin
+            t2 = get_time() + UNDERSHOOT_MARGIN
+
+            # max_strokes reached, or temporal window has expired. The gesture
+            # is complete; need to dispatch _complete or _discard event.
+            if not g.accept_stroke() or t1 <= t2:
+                discard = False
+                if g.width < 5 and g.height < 5:
+                    discard = True
+                elif g.single_points_test():
+                    discard = True
+
+                need_cleanup = True
+                g.active = False
+                g._cleanup_time = get_time() + timeout
+
+                if discard:
+                    self.dispatch('on_gesture_discard', g)
+                else:
+                    self.dispatch('on_gesture_complete', g)
+
+        if need_cleanup:
+            Clock.schedule_once(self._cleanup, timeout)
+
+    def _cleanup(self, dt):
+        '''This method is scheduled from _complete_dispatcher to clean up the
+        canvas and internal gesture list after a gesture is completed.'''
+        m = UNDERSHOOT_MARGIN
+        rg = self.canvas.remove_group
+        gestures = self._gestures
+        for idx, g in enumerate(gestures):
+            if g._cleanup_time is None:
+                continue
+            if g._cleanup_time <= Clock.get_time() + m:
+                rg(g.id)
+                del gestures[idx]
+                self.dispatch('on_gesture_cleanup', g)
+
+    def on_gesture_start(self, *l):
+        pass
+
+    def on_gesture_extend(self, *l):
+        pass
+
+    def on_gesture_merge(self, *l):
+        pass
+
+    def on_gesture_complete(self, *l):
+        pass
+
+    def on_gesture_discard(self, *l):
+        pass
+
+    def on_gesture_cleanup(self, *l):
+        pass
diff --git a/kivy/uix/gridlayout.py b/kivy/uix/gridlayout.py
new file mode 100644
index 0000000..0c67776
--- /dev/null
+++ b/kivy/uix/gridlayout.py
@@ -0,0 +1,629 @@
+'''
+Grid Layout
+===========
+
+.. only:: html
+
+    .. image:: images/gridlayout.gif
+        :align: right
+
+.. only:: latex
+
+    .. image:: images/gridlayout.png
+        :align: right
+
+.. versionadded:: 1.0.4
+
+The :class:`GridLayout` arranges children in a matrix. It takes the available
+space and divides it into columns and rows, then adds widgets to the resulting
+"cells".
+
+.. versionchanged:: 1.0.7
+    The implementation has changed to use the widget size_hint for calculating
+    column/row sizes. `uniform_width` and `uniform_height` have been removed
+    and other properties have added to give you more control.
+
+Background
+----------
+
+Unlike many other toolkits, you cannot explicitly place a widget in a specific
+column/row. Each child is automatically assigned a position determined by the
+layout configuration and the child's index in the children list.
+
+A GridLayout must always have at least one input constraint:
+:attr:`GridLayout.cols` or :attr:`GridLayout.rows`. If you do not specify cols
+or rows, the Layout will throw an exception.
+
+Column Width and Row Height
+---------------------------
+
+The column width/row height are determined in 3 steps:
+
+    - The initial size is given by the :attr:`col_default_width` and
+      :attr:`row_default_height` properties. To customize the size of a single
+      column or row, use :attr:`cols_minimum` or :attr:`rows_minimum`.
+    - The `size_hint_x`/`size_hint_y` of the children are taken into account.
+      If no widgets have a size hint, the maximum size is used for all
+      children.
+    - You can force the default size by setting the :attr:`col_force_default`
+      or :attr:`row_force_default` property. This will force the layout to
+      ignore the `width` and `size_hint` properties of children and use the
+      default size.
+
+Using a GridLayout
+------------------
+
+In the example below, all widgets will have an equal size. By default, the
+`size_hint` is (1, 1), so a Widget will take the full size of the parent::
+
+    layout = GridLayout(cols=2)
+    layout.add_widget(Button(text='Hello 1'))
+    layout.add_widget(Button(text='World 1'))
+    layout.add_widget(Button(text='Hello 2'))
+    layout.add_widget(Button(text='World 2'))
+
+.. image:: images/gridlayout_1.jpg
+
+Now, let's fix the size of Hello buttons to 100px instead of using
+size_hint_x=1::
+
+    layout = GridLayout(cols=2)
+    layout.add_widget(Button(text='Hello 1', size_hint_x=None, width=100))
+    layout.add_widget(Button(text='World 1'))
+    layout.add_widget(Button(text='Hello 2', size_hint_x=None, width=100))
+    layout.add_widget(Button(text='World 2'))
+
+.. image:: images/gridlayout_2.jpg
+
+Next, let's fix the row height to a specific size::
+
+    layout = GridLayout(cols=2, row_force_default=True, row_default_height=40)
+    layout.add_widget(Button(text='Hello 1', size_hint_x=None, width=100))
+    layout.add_widget(Button(text='World 1'))
+    layout.add_widget(Button(text='Hello 2', size_hint_x=None, width=100))
+    layout.add_widget(Button(text='World 2'))
+
+.. image:: images/gridlayout_3.jpg
+
+'''
+
+__all__ = ('GridLayout', 'GridLayoutException')
+
+from kivy.logger import Logger
+from kivy.uix.layout import Layout
+from kivy.properties import NumericProperty, BooleanProperty, DictProperty, \
+    BoundedNumericProperty, ReferenceListProperty, VariableListProperty, \
+    ObjectProperty, StringProperty, OptionProperty
+from math import ceil
+from itertools import accumulate, product, chain, islice
+from operator import sub
+
+
+def nmax(*args):
+    # merge into one list
+    args = [x for x in args if x is not None]
+    return max(args)
+
+
+def nmin(*args):
+    # merge into one list
+    args = [x for x in args if x is not None]
+    return min(args)
+
+
+class GridLayoutException(Exception):
+    '''Exception for errors if the grid layout manipulation fails.
+    '''
+    pass
+
+
+class GridLayout(Layout):
+    '''Grid layout class. See module documentation for more information.
+    '''
+
+    spacing = VariableListProperty([0, 0], length=2)
+    '''Spacing between children: [spacing_horizontal, spacing_vertical].
+
+    spacing also accepts a one argument form [spacing].
+
+    :attr:`spacing` is a
+    :class:`~kivy.properties.VariableListProperty` and defaults to [0, 0].
+    '''
+
+    padding = VariableListProperty([0, 0, 0, 0])
+    '''Padding between the layout box and its children: [padding_left,
+    padding_top, padding_right, padding_bottom].
+
+    padding also accepts a two argument form [padding_horizontal,
+    padding_vertical] and a one argument form [padding].
+
+    .. versionchanged:: 1.7.0
+        Replaced NumericProperty with VariableListProperty.
+
+    :attr:`padding` is a :class:`~kivy.properties.VariableListProperty` and
+    defaults to [0, 0, 0, 0].
+    '''
+
+    cols = BoundedNumericProperty(None, min=0, allownone=True)
+    '''Number of columns in the grid.
+
+    .. versionchanged:: 1.0.8
+        Changed from a NumericProperty to BoundedNumericProperty. You can no
+        longer set this to a negative value.
+
+    :attr:`cols` is a :class:`~kivy.properties.NumericProperty` and defaults to
+    None.
+    '''
+
+    rows = BoundedNumericProperty(None, min=0, allownone=True)
+    '''Number of rows in the grid.
+
+    .. versionchanged:: 1.0.8
+        Changed from a NumericProperty to a BoundedNumericProperty. You can no
+        longer set this to a negative value.
+
+    :attr:`rows` is a :class:`~kivy.properties.NumericProperty` and defaults to
+    None.
+    '''
+
+    col_default_width = NumericProperty(0)
+    '''Default minimum size to use for a column.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`col_default_width` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    row_default_height = NumericProperty(0)
+    '''Default minimum size to use for row.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`row_default_height` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    col_force_default = BooleanProperty(False)
+    '''If True, ignore the width and size_hint_x of the child and use the
+    default column width.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`col_force_default` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to False.
+    '''
+
+    row_force_default = BooleanProperty(False)
+    '''If True, ignore the height and size_hint_y of the child and use the
+    default row height.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`row_force_default` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to False.
+    '''
+
+    cols_minimum = DictProperty({})
+    '''Dict of minimum width for each column. The dictionary keys are the
+    column numbers, e.g. 0, 1, 2...
+
+    .. versionadded:: 1.0.7
+
+    :attr:`cols_minimum` is a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+    '''
+
+    rows_minimum = DictProperty({})
+    '''Dict of minimum height for each row. The dictionary keys are the
+    row numbers, e.g. 0, 1, 2...
+
+    .. versionadded:: 1.0.7
+
+    :attr:`rows_minimum` is a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+    '''
+
+    minimum_width = NumericProperty(0)
+    '''Automatically computed minimum width needed to contain all children.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`minimum_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0. It is read only.
+    '''
+
+    minimum_height = NumericProperty(0)
+    '''Automatically computed minimum height needed to contain all children.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`minimum_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0. It is read only.
+    '''
+
+    minimum_size = ReferenceListProperty(minimum_width, minimum_height)
+    '''Automatically computed minimum size needed to contain all children.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`minimum_size` is a
+    :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`minimum_width`, :attr:`minimum_height`) properties. It is read
+    only.
+    '''
+
+    orientation = OptionProperty('lr-tb', options=(
+        'lr-tb', 'tb-lr', 'rl-tb', 'tb-rl', 'lr-bt', 'bt-lr', 'rl-bt',
+        'bt-rl'))
+    '''Orientation of the layout.
+
+    :attr:`orientation` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'lr-tb'.
+
+    Valid orientations are 'lr-tb', 'tb-lr', 'rl-tb', 'tb-rl', 'lr-bt',
+    'bt-lr', 'rl-bt' and 'bt-rl'.
+
+    .. versionadded:: 2.0.0
+
+    .. note::
+
+        'lr' means Left to Right.
+        'rl' means Right to Left.
+        'tb' means Top to Bottom.
+        'bt' means Bottom to Top.
+    '''
+
+    def __init__(self, **kwargs):
+        self._cols = self._rows = None
+        super(GridLayout, self).__init__(**kwargs)
+        fbind = self.fbind
+        update = self._trigger_layout
+        fbind('col_default_width', update)
+        fbind('row_default_height', update)
+        fbind('col_force_default', update)
+        fbind('row_force_default', update)
+        fbind('cols', update)
+        fbind('rows', update)
+        fbind('parent', update)
+        fbind('spacing', update)
+        fbind('padding', update)
+        fbind('children', update)
+        fbind('size', update)
+        fbind('pos', update)
+        fbind('orientation', update)
+
+    def get_max_widgets(self):
+        if self.cols and self.rows:
+            return self.rows * self.cols
+        else:
+            return None
+
+    def on_children(self, instance, value):
+        # if that makes impossible to construct things with deferred method,
+        # migrate this test in do_layout, and/or issue a warning.
+        smax = self.get_max_widgets()
+        if smax and len(value) > smax:
+            raise GridLayoutException(
+                'Too many children in GridLayout. Increase rows/cols!')
+
+    @property
+    def _fills_row_first(self):
+        return self.orientation[0] in 'lr'
+
+    @property
+    def _fills_from_left_to_right(self):
+        return 'lr' in self.orientation
+
+    @property
+    def _fills_from_top_to_bottom(self):
+        return 'tb' in self.orientation
+
+    def _init_rows_cols_sizes(self, count):
+        # the goal here is to calculate the minimum size of every cols/rows
+        # and determine if they have stretch or not
+        current_cols = self.cols
+        current_rows = self.rows
+
+        # if no cols or rows are set, we can't calculate minimum size.
+        # the grid must be constrained at least on one side
+        if not current_cols and not current_rows:
+            Logger.warning('%r have no cols or rows set, '
+                           'layout is not triggered.' % self)
+            return
+
+        if current_cols is None:
+            current_cols = int(ceil(count / float(current_rows)))
+        elif current_rows is None:
+            current_rows = int(ceil(count / float(current_cols)))
+
+        current_cols = max(1, current_cols)
+        current_rows = max(1, current_rows)
+
+        self._has_hint_bound_x = False
+        self._has_hint_bound_y = False
+        self._cols_min_size_none = 0.  # min size from all the None hint
+        self._rows_min_size_none = 0.  # min size from all the None hint
+        self._cols = cols = [self.col_default_width] * current_cols
+        self._cols_sh = [None] * current_cols
+        self._cols_sh_min = [None] * current_cols
+        self._cols_sh_max = [None] * current_cols
+        self._rows = rows = [self.row_default_height] * current_rows
+        self._rows_sh = [None] * current_rows
+        self._rows_sh_min = [None] * current_rows
+        self._rows_sh_max = [None] * current_rows
+
+        # update minimum size from the dicts
+        items = (i for i in self.cols_minimum.items() if i[0] < len(cols))
+        for index, value in items:
+            cols[index] = max(value, cols[index])
+
+        items = (i for i in self.rows_minimum.items() if i[0] < len(rows))
+        for index, value in items:
+            rows[index] = max(value, rows[index])
+        return True
+
+    def _fill_rows_cols_sizes(self):
+        cols, rows = self._cols, self._rows
+        cols_sh, rows_sh = self._cols_sh, self._rows_sh
+        cols_sh_min, rows_sh_min = self._cols_sh_min, self._rows_sh_min
+        cols_sh_max, rows_sh_max = self._cols_sh_max, self._rows_sh_max
+
+        # calculate minimum size for each columns and rows
+        has_bound_y = has_bound_x = False
+        idx_iter = self._create_idx_iter(len(cols), len(rows))
+        for child, (col, row) in zip(reversed(self.children), idx_iter):
+            (shw, shh), (w, h) = child.size_hint, child.size
+            shw_min, shh_min = child.size_hint_min
+            shw_max, shh_max = child.size_hint_max
+
+            # compute minimum size / maximum stretch needed
+            if shw is None:
+                cols[col] = nmax(cols[col], w)
+            else:
+                cols_sh[col] = nmax(cols_sh[col], shw)
+                if shw_min is not None:
+                    has_bound_x = True
+                    cols_sh_min[col] = nmax(cols_sh_min[col], shw_min)
+                if shw_max is not None:
+                    has_bound_x = True
+                    cols_sh_max[col] = nmin(cols_sh_max[col], shw_max)
+
+            if shh is None:
+                rows[row] = nmax(rows[row], h)
+            else:
+                rows_sh[row] = nmax(rows_sh[row], shh)
+                if shh_min is not None:
+                    has_bound_y = True
+                    rows_sh_min[row] = nmax(rows_sh_min[row], shh_min)
+                if shh_max is not None:
+                    has_bound_y = True
+                    rows_sh_max[row] = nmin(rows_sh_max[row], shh_max)
+        self._has_hint_bound_x = has_bound_x
+        self._has_hint_bound_y = has_bound_y
+
+    def _update_minimum_size(self):
+        # calculate minimum width/height needed, starting from padding +
+        # spacing
+        l, t, r, b = self.padding
+        spacing_x, spacing_y = self.spacing
+        cols, rows = self._cols, self._rows
+
+        width = l + r + spacing_x * (len(cols) - 1)
+        self._cols_min_size_none = sum(cols) + width
+        # we need to subtract for the sh_max/min the already guaranteed size
+        # due to having a None in the col. So sh_min gets smaller by that size
+        # since it's already covered. Similarly for sh_max, because if we
+        # already exceeded the max, the subtracted max will be zero, so
+        # it won't get larger
+        if self._has_hint_bound_x:
+            cols_sh_min = self._cols_sh_min
+            cols_sh_max = self._cols_sh_max
+
+            for i, (c, sh_min, sh_max) in enumerate(
+                    zip(cols, cols_sh_min, cols_sh_max)):
+                if sh_min is not None:
+                    width += max(c, sh_min)
+                    cols_sh_min[i] = max(0., sh_min - c)
+                else:
+                    width += c
+
+                if sh_max is not None:
+                    cols_sh_max[i] = max(0., sh_max - c)
+        else:
+            width = self._cols_min_size_none
+
+        height = t + b + spacing_y * (len(rows) - 1)
+        self._rows_min_size_none = sum(rows) + height
+        if self._has_hint_bound_y:
+            rows_sh_min = self._rows_sh_min
+            rows_sh_max = self._rows_sh_max
+
+            for i, (r, sh_min, sh_max) in enumerate(
+                    zip(rows, rows_sh_min, rows_sh_max)):
+                if sh_min is not None:
+                    height += max(r, sh_min)
+                    rows_sh_min[i] = max(0., sh_min - r)
+                else:
+                    height += r
+
+                if sh_max is not None:
+                    rows_sh_max[i] = max(0., sh_max - r)
+        else:
+            height = self._rows_min_size_none
+
+        # finally, set the minimum size
+        self.minimum_size = (width, height)
+
+    def _finalize_rows_cols_sizes(self):
+        selfw = self.width
+        selfh = self.height
+
+        # resolve size for each column
+        if self.col_force_default:
+            cols = [self.col_default_width] * len(self._cols)
+            for index, value in self.cols_minimum.items():
+                cols[index] = value
+            self._cols = cols
+        else:
+            cols = self._cols
+            cols_sh = self._cols_sh
+            cols_sh_min = self._cols_sh_min
+            cols_weight = float(sum((x for x in cols_sh if x is not None)))
+            stretch_w = max(0., selfw - self._cols_min_size_none)
+
+            if stretch_w > 1e-9:
+                if self._has_hint_bound_x:
+                    # fix the hints to be within bounds
+                    self.layout_hint_with_bounds(
+                        cols_weight, stretch_w,
+                        sum((c for c in cols_sh_min if c is not None)),
+                        cols_sh_min, self._cols_sh_max, cols_sh)
+
+                for index, col_stretch in enumerate(cols_sh):
+                    # if the col don't have stretch information, nothing to do
+                    if not col_stretch:
+                        continue
+                    # add to the min width whatever remains from size_hint
+                    cols[index] += stretch_w * col_stretch / cols_weight
+
+        # same algo for rows
+        if self.row_force_default:
+            rows = [self.row_default_height] * len(self._rows)
+            for index, value in self.rows_minimum.items():
+                rows[index] = value
+            self._rows = rows
+        else:
+            rows = self._rows
+            rows_sh = self._rows_sh
+            rows_sh_min = self._rows_sh_min
+            rows_weight = float(sum((x for x in rows_sh if x is not None)))
+            stretch_h = max(0., selfh - self._rows_min_size_none)
+
+            if stretch_h > 1e-9:
+                if self._has_hint_bound_y:
+                    # fix the hints to be within bounds
+                    self.layout_hint_with_bounds(
+                        rows_weight, stretch_h,
+                        sum((r for r in rows_sh_min if r is not None)),
+                        rows_sh_min, self._rows_sh_max, rows_sh)
+
+                for index, row_stretch in enumerate(rows_sh):
+                    # if the row don't have stretch information, nothing to do
+                    if not row_stretch:
+                        continue
+                    # add to the min height whatever remains from size_hint
+                    rows[index] += stretch_h * row_stretch / rows_weight
+
+    def _iterate_layout(self, count):
+        orientation = self.orientation
+        padding = self.padding
+        spacing_x, spacing_y = self.spacing
+
+        cols = self._cols
+        if self._fills_from_left_to_right:
+            x_iter = accumulate(chain(
+                (self.x + padding[0], ),
+                (
+                    col_width + spacing_x
+                    for col_width in islice(cols, len(cols) - 1)
+                ),
+            ))
+        else:
+            x_iter = accumulate(chain(
+                (self.right - padding[2] - cols[-1], ),
+                (
+                    col_width + spacing_x
+                    for col_width in islice(reversed(cols), 1, None)
+                ),
+            ), sub)
+            cols = reversed(cols)
+
+        rows = self._rows
+        if self._fills_from_top_to_bottom:
+            y_iter = accumulate(chain(
+                (self.top - padding[1] - rows[0], ),
+                (
+                    row_height + spacing_y
+                    for row_height in islice(rows, 1, None)
+                ),
+            ), sub)
+        else:
+            y_iter = accumulate(chain(
+                (self.y + padding[3], ),
+                (
+                    row_height + spacing_y
+                    for row_height in islice(reversed(rows), len(rows) - 1)
+                ),
+            ))
+            rows = reversed(rows)
+
+        if self._fills_row_first:
+            for i, (y, x), (row_height, col_width) in zip(
+                    reversed(range(count)),
+                    product(y_iter, x_iter),
+                    product(rows, cols)):
+                yield i, x, y, col_width, row_height
+        else:
+            for i, (x, y), (col_width, row_height) in zip(
+                    reversed(range(count)),
+                    product(x_iter, y_iter),
+                    product(cols, rows)):
+                yield i, x, y, col_width, row_height
+
+    def do_layout(self, *largs):
+        children = self.children
+        if not children or not self._init_rows_cols_sizes(len(children)):
+            l, t, r, b = self.padding
+            self.minimum_size = l + r, t + b
+            return
+        self._fill_rows_cols_sizes()
+        self._update_minimum_size()
+        self._finalize_rows_cols_sizes()
+
+        for i, x, y, w, h in self._iterate_layout(len(children)):
+            c = children[i]
+            c.pos = x, y
+            shw, shh = c.size_hint
+            shw_min, shh_min = c.size_hint_min
+            shw_max, shh_max = c.size_hint_max
+
+            if shw_min is not None:
+                if shw_max is not None:
+                    w = max(min(w, shw_max), shw_min)
+                else:
+                    w = max(w, shw_min)
+            else:
+                if shw_max is not None:
+                    w = min(w, shw_max)
+
+            if shh_min is not None:
+                if shh_max is not None:
+                    h = max(min(h, shh_max), shh_min)
+                else:
+                    h = max(h, shh_min)
+            else:
+                if shh_max is not None:
+                    h = min(h, shh_max)
+
+            if shw is None:
+                if shh is not None:
+                    c.height = h
+            else:
+                if shh is None:
+                    c.width = w
+                else:
+                    c.size = (w, h)
+
+    def _create_idx_iter(self, n_cols, n_rows):
+        col_indices = range(n_cols) if self._fills_from_left_to_right \
+            else range(n_cols - 1, -1, -1)
+        row_indices = range(n_rows) if self._fills_from_top_to_bottom \
+            else range(n_rows - 1, -1, -1)
+
+        if self._fills_row_first:
+            return (
+                (col_index, row_index)
+                for row_index, col_index in product(row_indices, col_indices))
+        else:
+            return product(col_indices, row_indices)
diff --git a/kivy/uix/image.py b/kivy/uix/image.py
new file mode 100644
index 0000000..1d0520b
--- /dev/null
+++ b/kivy/uix/image.py
@@ -0,0 +1,434 @@
+'''
+Image
+=====
+
+The :class:`Image` widget is used to display an image::
+
+Example in python::
+
+    wimg = Image(source='mylogo.png')
+
+Kv Example::
+
+    Image:
+        source: 'mylogo.png'
+        size: self.texture_size
+
+
+Asynchronous Loading
+--------------------
+
+To load an image asynchronously (for example from an external webserver), use
+the :class:`AsyncImage` subclass::
+
+    aimg = AsyncImage(source='http://mywebsite.com/logo.png')
+
+This can be useful as it prevents your application from waiting until the image
+is loaded. If you want to display large images or retrieve them from URL's,
+using :class:`AsyncImage` will allow these resources to be retrieved on a
+background thread without blocking your application.
+
+Alignment
+---------
+
+By default, the image is centered and fits inside the widget bounding box.
+If you don't want that, you can set `allow_stretch` to True and `keep_ratio`
+to False.
+
+You can also inherit from Image and create your own style. For example, if you
+want your image to be greater than the size of your widget, you could do::
+
+    class FullImage(Image):
+        pass
+
+And in your kivy language file::
+
+    <-FullImage>:
+        canvas:
+            Color:
+                rgb: (1, 1, 1)
+            Rectangle:
+                texture: self.texture
+                size: self.width + 20, self.height + 20
+                pos: self.x - 10, self.y - 10
+
+'''
+__all__ = ('Image', 'AsyncImage')
+
+from kivy.uix.widget import Widget
+from kivy.core.image import Image as CoreImage
+from kivy.resources import resource_find
+from kivy.properties import StringProperty, ObjectProperty, ListProperty, \
+    AliasProperty, BooleanProperty, NumericProperty, ColorProperty
+from kivy.logger import Logger
+
+# delayed imports
+Loader = None
+
+
+class Image(Widget):
+    '''Image class, see module documentation for more information.
+    '''
+
+    source = StringProperty(None)
+    '''Filename / source of your image.
+
+    :attr:`source` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    texture = ObjectProperty(None, allownone=True)
+    '''Texture object of the image. The texture represents the original, loaded
+    image texture. It is stretched and positioned during rendering according to
+    the :attr:`allow_stretch` and :attr:`keep_ratio` properties.
+
+    Depending of the texture creation, the value will be a
+    :class:`~kivy.graphics.texture.Texture` or a
+    :class:`~kivy.graphics.texture.TextureRegion` object.
+
+    :attr:`texture` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    texture_size = ListProperty([0, 0])
+    '''Texture size of the image. This represents the original, loaded image
+    texture size.
+
+    .. warning::
+
+        The texture size is set after the texture property. So if you listen to
+        the change on :attr:`texture`, the property texture_size will not be
+        up-to-date. Use self.texture.size instead.
+    '''
+
+    def get_image_ratio(self):
+        if self.texture:
+            return self.texture.width / float(self.texture.height)
+        return 1.
+
+    mipmap = BooleanProperty(False)
+    '''Indicate if you want OpenGL mipmapping to be applied to the texture.
+    Read :ref:`mipmap` for more information.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`mipmap` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    image_ratio = AliasProperty(get_image_ratio, bind=('texture',), cache=True)
+    '''Ratio of the image (width / float(height).
+
+    :attr:`image_ratio` is an :class:`~kivy.properties.AliasProperty` and is
+    read-only.
+    '''
+
+    color = ColorProperty([1, 1, 1, 1])
+    '''Image color, in the format (r, g, b, a). This attribute can be used to
+    'tint' an image. Be careful: if the source image is not gray/white, the
+    color will not really work as expected.
+
+    .. versionadded:: 1.0.6
+
+    :attr:`color` is a :class:`~kivy.properties.ColorProperty` and defaults to
+    [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    allow_stretch = BooleanProperty(False)
+    '''If True, the normalized image size will be maximized to fit in the image
+    box. Otherwise, if the box is too tall, the image will not be
+    stretched more than 1:1 pixels.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`allow_stretch` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    keep_ratio = BooleanProperty(True)
+    '''If False along with allow_stretch being True, the normalized image
+    size will be maximized to fit in the image box and ignores the aspect
+    ratio of the image.
+    Otherwise, if the box is too tall, the image will not be stretched more
+    than 1:1 pixels.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`keep_ratio` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    keep_data = BooleanProperty(False)
+    '''If True, the underlying _coreimage will store the raw image data.
+    This is useful when performing pixel based collision detection.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`keep_data` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    anim_delay = NumericProperty(.25)
+    '''Delay the animation if the image is sequenced (like an animated gif).
+    If anim_delay is set to -1, the animation will be stopped.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`anim_delay` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.25 (4 FPS).
+    '''
+
+    anim_loop = NumericProperty(0)
+    '''Number of loops to play then stop animating. 0 means keep animating.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`anim_loop` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    nocache = BooleanProperty(False)
+    '''If this property is set True, the image will not be added to the
+    internal cache. The cache will simply ignore any calls trying to
+    append the core image.
+
+    .. versionadded:: 1.6.0
+
+    :attr:`nocache` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    def get_norm_image_size(self):
+        if not self.texture:
+            return list(self.size)
+        ratio = self.image_ratio
+        w, h = self.size
+        tw, th = self.texture.size
+
+        # ensure that the width is always maximized to the container width
+        if self.allow_stretch:
+            if not self.keep_ratio:
+                return [w, h]
+            iw = w
+        else:
+            iw = min(w, tw)
+        # calculate the appropriate height
+        ih = iw / ratio
+        # if the height is too higher, take the height of the container
+        # and calculate appropriate width. no need to test further. :)
+        if ih > h:
+            if self.allow_stretch:
+                ih = h
+            else:
+                ih = min(h, th)
+            iw = ih * ratio
+        return [iw, ih]
+
+    norm_image_size = AliasProperty(get_norm_image_size,
+                                    bind=('texture', 'size', 'allow_stretch',
+                                          'image_ratio', 'keep_ratio'),
+                                    cache=True)
+    '''Normalized image size within the widget box.
+
+    This size will always fit the widget size and will preserve the image
+    ratio.
+
+    :attr:`norm_image_size` is an :class:`~kivy.properties.AliasProperty` and
+    is read-only.
+    '''
+
+    def __init__(self, **kwargs):
+        self._coreimage = None
+        self._loops = 0
+        update = self.texture_update
+        fbind = self.fbind
+        fbind('source', update)
+        fbind('mipmap', update)
+        super().__init__(**kwargs)
+
+    def texture_update(self, *largs):
+        self.set_texture_from_resource(self.source)
+
+    def set_texture_from_resource(self, resource):
+        if not resource:
+            self._clear_core_image()
+            return
+        source = resource_find(resource)
+        if not source:
+            Logger.error('Image: Not found <%s>' % resource)
+            self._clear_core_image()
+            return
+        if self._coreimage:
+            self._coreimage.unbind(on_texture=self._on_tex_change)
+        try:
+            self._coreimage = image = CoreImage(
+                source,
+                mipmap=self.mipmap,
+                anim_delay=self.anim_delay,
+                keep_data=self.keep_data,
+                nocache=self.nocache
+            )
+        except Exception:
+            Logger.error('Image: Error loading <%s>' % resource)
+            self._clear_core_image()
+            image = self._coreimage
+        if image:
+            image.bind(on_texture=self._on_tex_change)
+            self.texture = image.texture
+
+    def on_anim_delay(self, instance, value):
+        if self._coreimage is None:
+            return
+        self._coreimage.anim_delay = value
+        if value < 0:
+            self._coreimage.anim_reset(False)
+
+    def on_texture(self, instance, value):
+        self.texture_size = value.size if value else [0, 0]
+
+    def _clear_core_image(self):
+        if self._coreimage:
+            self._coreimage.unbind(on_texture=self._on_tex_change)
+        self.texture = None
+        self._coreimage = None
+        self._loops = 0
+
+    def _on_tex_change(self, *largs):
+        # update texture from core image
+        self.texture = self._coreimage.texture
+        ci = self._coreimage
+        if self.anim_loop and ci._anim_index == len(ci._image.textures) - 1:
+            self._loops += 1
+            if self.anim_loop == self._loops:
+                ci.anim_reset(False)
+                self._loops = 0
+
+    def reload(self):
+        '''Reload image from disk. This facilitates re-loading of
+        images from disk in case the image content changes.
+
+        .. versionadded:: 1.3.0
+
+        Usage::
+
+            im = Image(source = '1.jpg')
+            # -- do something --
+            im.reload()
+            # image will be re-loaded from disk
+
+        '''
+        self.remove_from_cache()
+        old_source = self.source
+        self.source = ''
+        self.source = old_source
+
+    def remove_from_cache(self):
+        '''Remove image from cache.
+
+        .. versionadded:: 2.0.0
+        '''
+        if self._coreimage:
+            self._coreimage.remove_from_cache()
+
+    def on_nocache(self, *args):
+        if self.nocache:
+            self.remove_from_cache()
+            if self._coreimage:
+                self._coreimage._nocache = True
+
+
+class AsyncImage(Image):
+    '''Asynchronous Image class. See the module documentation for more
+    information.
+
+    .. note::
+
+        The AsyncImage is a specialized form of the Image class. You may
+        want to refer to the :mod:`~kivy.loader` documentation and in
+        particular, the :class:`~kivy.loader.ProxyImage` for more detail
+        on how to handle events around asynchronous image loading.
+
+    .. note::
+
+        AsyncImage currently does not support properties
+        :attr:`anim_loop` and :attr:`mipmap` and setting those properties will
+        have no effect.
+    '''
+
+    __events__ = ('on_error', 'on_load')
+
+    def __init__(self, **kwargs):
+        self._found_source = None
+        self._coreimage = None
+        global Loader
+        if not Loader:
+            from kivy.loader import Loader
+        self.fbind('source', self._load_source)
+        super().__init__(**kwargs)
+
+    def _load_source(self, *args):
+        source = self.source
+        if not source:
+            self._clear_core_image()
+            return
+        if not self.is_uri(source):
+            source = resource_find(source)
+            if not source:
+                Logger.error('AsyncImage: Not found <%s>' % self.source)
+                self._clear_core_image()
+                return
+        self._found_source = source
+        self._coreimage = image = Loader.image(
+            source,
+            nocache=self.nocache,
+            mipmap=self.mipmap,
+            anim_delay=self.anim_delay
+        )
+        image.bind(
+            on_load=self._on_source_load,
+            on_error=self._on_source_error,
+            on_texture=self._on_tex_change
+        )
+        self.texture = image.texture
+
+    def _on_source_load(self, value):
+        image = self._coreimage.image
+        if not image:
+            return
+        self.texture = image.texture
+        self.dispatch('on_load')
+
+    def _on_source_error(self, instance, error=None):
+        self.dispatch('on_error', error)
+
+    def on_error(self, error):
+        pass
+
+    def on_load(self, *args):
+        pass
+
+    def is_uri(self, filename):
+        proto = filename.split('://', 1)[0]
+        return proto in ('http', 'https', 'ftp', 'smb')
+
+    def _clear_core_image(self):
+        if self._coreimage:
+            self._coreimage.unbind(on_load=self._on_source_load)
+        super()._clear_core_image()
+        self._found_source = None
+
+    def _on_tex_change(self, *largs):
+        if self._coreimage:
+            self.texture = self._coreimage.texture
+
+    def texture_update(self, *largs):
+        pass
+
+    def remove_from_cache(self):
+        if self._found_source:
+            Loader.remove_from_cache(self._found_source)
+        super().remove_from_cache()
diff --git a/kivy/uix/label.py b/kivy/uix/label.py
new file mode 100644
index 0000000..2b2836f
--- /dev/null
+++ b/kivy/uix/label.py
@@ -0,0 +1,1107 @@
+'''Label
+=====
+
+.. image:: images/label.png
+    :align: right
+
+The :class:`Label` widget is for rendering text::
+
+    # hello world text
+    l = Label(text='Hello world')
+
+    # unicode text; can only display glyphs that are available in the font
+    l = Label(text='Hello world ' + chr(2764))
+
+    # multiline text
+    l = Label(text='Multi\\nLine')
+
+    # size
+    l = Label(text='Hello world', font_size='20sp')
+
+.. _kivy-uix-label-sizing-and-text-content:
+
+Sizing and text content
+---------------------------
+
+By default, the size of :class:`Label` is not affected by :attr:`~Label.text`
+content and the text is not affected by the size. In order to control
+sizing, you must specify :attr:`~Label.text_size` to constrain the text
+and/or bind :attr:`~Label.size` to :attr:`~Label.texture_size` to grow with
+the text.
+
+For example, this label's size will be set to the text content
+(plus :attr:`~Label.padding`):
+
+.. code-block:: kv
+
+    Label:
+        size: self.texture_size
+
+This label's text will wrap at the specified width and be clipped to the
+height:
+
+.. code-block:: kv
+
+    Label:
+        text_size: cm(6), cm(4)
+
+.. note:: The :attr:`~Label.shorten` and :attr:`~Label.max_lines` attributes
+ control how overflowing text behaves.
+
+Combine these concepts to create a Label that can grow vertically but wraps the
+text at a certain width:
+
+.. code-block:: kv
+
+    Label:
+        text_size: root.width, None
+        size: self.texture_size
+
+How to have a custom background color in the label:
+
+.. code-block:: kv
+
+    # Define your background color Template
+    <BackgroundColor@Widget>
+        background_color: 1, 1, 1, 1
+        canvas.before:
+            Color:
+                rgba: root.background_color
+            Rectangle:
+                size: self.size
+                pos: self.pos
+    # Now you can simply Mix the `BackgroundColor` class with almost
+    # any other widget... to give it a background.
+    <BackgroundLabel@Label+BackgroundColor>
+        background_color: 0, 0, 0, 0
+        # Default the background color for this label
+        # to r 0, g 0, b 0, a 0
+    # Use the BackgroundLabel any where in your kv code like below
+    BackgroundLabel
+        text: 'Hello'
+        background_color: 1, 0, 0, 1
+
+Text alignment and wrapping
+---------------------------
+
+The :class:`Label` has :attr:`~Label.halign` and :attr:`~Label.valign`
+properties to control the alignment of its text. However, by default the text
+image (:attr:`~Label.texture`) is only just large enough to contain the
+characters and is positioned in the center of the Label. The valign property
+will have no effect and halign will only have an effect if your text has
+newlines; a single line of text will appear to be centered even though halign
+is set to left (by default).
+
+In order for the alignment properties to take effect, set the
+:attr:`~Label.text_size`, which specifies the size of the bounding box within
+which text is aligned. For instance, the following code binds this size to the
+size of the Label, so text will be aligned within the widget bounds. This
+will also automatically wrap the text of the Label to remain within this area.
+
+.. code-block:: kv
+
+    Label:
+        text_size: self.size
+        halign: 'right'
+        valign: 'middle'
+
+Markup text
+-----------
+
+.. versionadded:: 1.1.0
+
+You can change the style of the text using :doc:`api-kivy.core.text.markup`.
+The syntax is similar to the bbcode syntax but only the inline styling is
+allowed::
+
+    # hello world with world in bold
+    l = Label(text='Hello [b]World[/b]', markup=True)
+
+    # hello in red, world in blue
+    l = Label(text='[color=ff3333]Hello[/color][color=3333ff]World[/color]',
+        markup = True)
+
+If you need to escape the markup from the current text, use
+:func:`kivy.utils.escape_markup`::
+
+    text = 'This is an important message [1]'
+    l = Label(text='[b]' + escape_markup(text) + '[/b]', markup=True)
+
+The following tags are available:
+
+``[b][/b]``
+    Activate bold text
+``[i][/i]``
+    Activate italic text
+``[u][/u]``
+    Underlined text
+``[s][/s]``
+    Strikethrough text
+``[font=<str>][/font]``
+    Change the font (note: this refers to a TTF file or registered alias)
+``[font_context=<str>][/font_context]``
+    Change context for the font, use string value "none" for isolated context
+    (this is equivalent to `None`; if you created a font context named
+    `'none'`, it cannot be referred to using markup)
+``[font_family=<str>][/font_family]``
+    Font family to request for drawing. This is only valid when using a
+    font context, see :class:`kivy.uix.label.Label` for details.
+``[font_features=<str>][/font_features]``
+    OpenType font features, in CSS format, this is passed straight
+    through to Pango. The effects of requesting a feature depends on loaded
+    fonts, library versions, etc. Pango only, requires v1.38 or later.
+``[size=<integer>][/size]``
+    Change the font size
+``[color=#<color>][/color]``
+    Change the text color
+``[ref=<str>][/ref]``
+    Add an interactive zone. The reference + bounding box inside the
+    reference will be available in :attr:`Label.refs`
+``[anchor=<str>]``
+    Put an anchor in the text. You can get the position of your anchor within
+    the text with :attr:`Label.anchors`
+``[sub][/sub]``
+    Display the text at a subscript position relative to the text before it.
+``[sup][/sup]``
+    Display the text at a superscript position relative to the text before it.
+``[text_language=<str>][/text_language]``
+    Language of the text, this is an RFC-3066 format language tag (as string),
+    for example "en_US", "zh_CN", "fr" or "ja". This can impact font selection
+    and metrics. Use the string "None" to revert to locale detection.
+    Pango only.
+
+If you want to render the markup text with a [ or ] or & character, you need to
+escape them. We created a simple syntax::
+
+    [   -> &bl;
+    ]   -> &br;
+    &   -> &amp;
+
+Then you can write::
+
+    "[size=24]Hello &bl;World&br;[/size]"
+
+Interactive zone in text
+------------------------
+
+.. versionadded:: 1.1.0
+
+You can now have definable "links" using text markup. The idea is to be able
+to detect when the user clicks on part of the text and to react.
+The tag ``[ref=xxx]`` is used for that.
+
+In this example, we are creating a reference on the word "World". When
+this word is clicked, the function ``print_it`` will be called with the
+name of the reference::
+
+    def print_it(instance, value):
+        print('User clicked on', value)
+    widget = Label(text='Hello [ref=world]World[/ref]', markup=True)
+    widget.bind(on_ref_press=print_it)
+
+For prettier rendering, you could add a color for the reference. Replace the
+``text=`` in the previous example with::
+
+    'Hello [ref=world][color=0000ff]World[/color][/ref]'
+
+Catering for Unicode languages
+------------------------------
+
+The font kivy uses does not contain all the characters required for displaying
+all languages. When you use the built-in widgets, this results in a block being
+drawn where you expect a character.
+
+If you want to display such characters, you can chose a font that supports them
+and deploy it universally via kv:
+
+.. code-block:: kv
+
+    <Label>:
+        font_name: '/<path>/<to>/<font>'
+
+Note that this needs to be done before your widgets are loaded as kv rules are
+only applied at load time.
+
+Usage example
+-------------
+
+The following example marks the anchors and references contained in a label::
+
+    from kivy.app import App
+    from kivy.uix.label import Label
+    from kivy.clock import Clock
+    from kivy.graphics import Color, Rectangle
+
+
+    class TestApp(App):
+
+        @staticmethod
+        def get_x(label, ref_x):
+            """ Return the x value of the ref/anchor relative to the canvas """
+            return label.center_x - label.texture_size[0] * 0.5 + ref_x
+
+        @staticmethod
+        def get_y(label, ref_y):
+            """ Return the y value of the ref/anchor relative to the canvas """
+            # Note the inversion of direction, as y values start at the top of
+            # the texture and increase downwards
+            return label.center_y + label.texture_size[1] * 0.5 - ref_y
+
+        def show_marks(self, label):
+
+            # Indicate the position of the anchors with a red top marker
+            for name, anc in label.anchors.items():
+                with label.canvas:
+                    Color(1, 0, 0)
+                    Rectangle(pos=(self.get_x(label, anc[0]),
+                                   self.get_y(label, anc[1])),
+                              size=(3, 3))
+
+            # Draw a green surround around the refs. Note the sizes y inversion
+            for name, boxes in label.refs.items():
+                for box in boxes:
+                    with label.canvas:
+                        Color(0, 1, 0, 0.25)
+                        Rectangle(pos=(self.get_x(label, box[0]),
+                                       self.get_y(label, box[1])),
+                                  size=(box[2] - box[0],
+                                        box[1] - box[3]))
+
+        def build(self):
+            label = Label(
+                text='[anchor=a]a\\nChars [anchor=b]b\\n[ref=myref]ref[/ref]',
+                markup=True)
+            Clock.schedule_once(lambda dt: self.show_marks(label), 1)
+            return label
+
+    TestApp().run()
+
+'''
+
+__all__ = ('Label', )
+
+from kivy.clock import Clock
+from kivy.uix.widget import Widget
+from kivy.core.text import Label as CoreLabel, DEFAULT_FONT
+from kivy.core.text.markup import MarkupLabel as CoreMarkupLabel
+from kivy.properties import StringProperty, OptionProperty, \
+    NumericProperty, BooleanProperty, ReferenceListProperty, \
+    ListProperty, ObjectProperty, DictProperty, ColorProperty
+from kivy.utils import get_hex_from_color
+
+
+class Label(Widget):
+    '''Label class, see module documentation for more information.
+
+    :Events:
+        `on_ref_press`
+            Fired when the user clicks on a word referenced with a
+            ``[ref]`` tag in a text markup.
+    '''
+
+    __events__ = ['on_ref_press']
+
+    _font_properties = ('text', 'font_size', 'font_name', 'bold', 'italic',
+                        'underline', 'strikethrough', 'font_family', 'color',
+                        'disabled_color', 'halign', 'valign', 'padding_x',
+                        'padding_y', 'outline_width', 'disabled_outline_color',
+                        'outline_color', 'text_size', 'shorten', 'mipmap',
+                        'line_height', 'max_lines', 'strip', 'shorten_from',
+                        'split_str', 'ellipsis_options', 'unicode_errors',
+                        'markup', 'font_hinting', 'font_kerning',
+                        'font_blended', 'font_context', 'font_features',
+                        'base_direction', 'text_language')
+
+    def __init__(self, **kwargs):
+        self._trigger_texture = Clock.create_trigger(self.texture_update, -1)
+        super(Label, self).__init__(**kwargs)
+
+        # bind all the property for recreating the texture
+        d = Label._font_properties
+        fbind = self.fbind
+        update = self._trigger_texture_update
+        fbind('disabled', update, 'disabled')
+        for x in d:
+            fbind(x, update, x)
+
+        self._label = None
+        self._create_label()
+
+        # force the texture creation
+        self._trigger_texture()
+
+    def _create_label(self):
+        # create the core label class according to markup value
+        if self._label is not None:
+            cls = self._label.__class__
+        else:
+            cls = None
+        markup = self.markup
+        if (markup and cls is not CoreMarkupLabel) or \
+           (not markup and cls is not CoreLabel):
+            # markup have change, we need to change our rendering method.
+            dkw = {x: getattr(self, x) for x in self._font_properties}
+            dkw['usersize'] = self.text_size
+            if self.disabled:
+                dkw['color'] = self.disabled_color
+                dkw['outline_color'] = self.disabled_outline_color
+
+            if markup:
+                self._label = CoreMarkupLabel(**dkw)
+            else:
+                self._label = CoreLabel(**dkw)
+
+    def _trigger_texture_update(self, name=None, source=None, value=None):
+        # check if the label core class need to be switch to a new one
+        if name == 'markup':
+            self._create_label()
+        if source:
+            if name == 'text':
+                self._label.text = value
+            elif name == 'text_size':
+                self._label.usersize = value
+            elif name == 'font_size':
+                self._label.options[name] = value
+            elif name == 'disabled_color' and self.disabled:
+                self._label.options['color'] = value
+            elif name == 'disabled_outline_color' and self.disabled:
+                self._label.options['outline_color'] = value
+            elif name == 'disabled':
+                self._label.options['color'] = self.disabled_color if value \
+                    else self.color
+                self._label.options['outline_color'] = (
+                    self.disabled_outline_color if value else
+                    self.outline_color)
+            else:
+                self._label.options[name] = value
+        self._trigger_texture()
+
+    def texture_update(self, *largs):
+        '''Force texture recreation with the current Label properties.
+
+        After this function call, the :attr:`texture` and :attr:`texture_size`
+        will be updated in this order.
+        '''
+        mrkup = self._label.__class__ is CoreMarkupLabel
+        self.texture = None
+
+        if (not self._label.text or
+                (self.halign == 'justify' or self.strip) and
+                not self._label.text.strip()):
+            self.texture_size = (0, 0)
+            self.is_shortened = False
+            if mrkup:
+                self.refs, self._label._refs = {}, {}
+                self.anchors, self._label._anchors = {}, {}
+        else:
+            if mrkup:
+                text = self.text
+                # we must strip here, otherwise, if the last line is empty,
+                # markup will retain the last empty line since it only strips
+                # line by line within markup
+                if self.halign == 'justify' or self.strip:
+                    text = text.strip()
+                self._label.text = ''.join(('[color=',
+                                            get_hex_from_color(
+                                                self.disabled_color if
+                                                self.disabled else self.color),
+                                            ']', text, '[/color]'))
+                self._label.refresh()
+                # force the rendering to get the references
+                if self._label.texture:
+                    self._label.texture.bind()
+                self.refs = self._label.refs
+                self.anchors = self._label.anchors
+            else:
+                self._label.refresh()
+            texture = self._label.texture
+            if texture is not None:
+                self.texture = self._label.texture
+                self.texture_size = list(self.texture.size)
+            self.is_shortened = self._label.is_shortened
+
+    def on_touch_down(self, touch):
+        if super(Label, self).on_touch_down(touch):
+            return True
+        if not len(self.refs):
+            return False
+        tx, ty = touch.pos
+        tx -= self.center_x - self.texture_size[0] / 2.
+        ty -= self.center_y - self.texture_size[1] / 2.
+        ty = self.texture_size[1] - ty
+        for uid, zones in self.refs.items():
+            for zone in zones:
+                x, y, w, h = zone
+                if x <= tx <= w and y <= ty <= h:
+                    self.dispatch('on_ref_press', uid)
+                    return True
+        return False
+
+    def on_ref_press(self, ref):
+        pass
+
+    #
+    # Properties
+    #
+
+    disabled_color = ColorProperty([1, 1, 1, .3])
+    '''The color of the text when the widget is disabled, in the (r, g, b, a)
+    format.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`disabled_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 1, 1, .3].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    text = StringProperty('')
+    '''Text of the label.
+
+    Creation of a simple hello world::
+
+        widget = Label(text='Hello world')
+
+    :attr:`text` is a :class:`~kivy.properties.StringProperty` and defaults to
+    ''.
+    '''
+
+    text_size = ListProperty([None, None])
+    '''By default, the label is not constrained to any bounding box.
+    You can set the size constraint of the label with this property.
+    The text will autoflow into the constraints. So although the font size
+    will not be reduced, the text will be arranged to fit into the box as best
+    as possible, with any text still outside the box clipped.
+
+    This sets and clips :attr:`texture_size` to text_size if not None.
+
+    .. versionadded:: 1.0.4
+
+    For example, whatever your current widget size is, if you want the label to
+    be created in a box with width=200 and unlimited height::
+
+        Label(text='Very big big line', text_size=(200, None))
+
+    .. note::
+
+        This text_size property is the same as the
+        :attr:`~kivy.core.text.Label.usersize` property in the
+        :class:`~kivy.core.text.Label` class. (It is named size= in the
+        constructor.)
+
+    :attr:`text_size` is a :class:`~kivy.properties.ListProperty` and
+    defaults to (None, None), meaning no size restriction by default.
+    '''
+
+    base_direction = OptionProperty(None,
+                     options=['ltr', 'rtl', 'weak_rtl', 'weak_ltr', None],
+                     allownone=True)
+    '''Base direction of text, this impacts horizontal alignment when
+    :attr:`halign` is `auto` (the default). Available options are: None,
+    "ltr" (left to right), "rtl" (right to left) plus "weak_ltr" and
+    "weak_rtl".
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. note::
+        Weak modes are currently not implemented in Kivy text layout, and
+        have the same effect as setting strong mode.
+
+    .. versionadded:: 1.11.0
+
+    :attr:`base_direction` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to None (autodetect RTL if possible, otherwise LTR).
+    '''
+
+    text_language = StringProperty(None, allownone=True)
+    '''Language of the text, if None Pango will determine it from locale.
+    This is an RFC-3066 format language tag (as a string), for example
+    "en_US", "zh_CN", "fr" or "ja". This can impact font selection, metrics
+    and rendering. For example, the same bytes of text can look different
+    for `ur` and `ar` languages, though both use Arabic script.
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. versionadded:: 1.11.0
+
+    :attr:`text_language` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    font_context = StringProperty(None, allownone=True)
+    '''Font context. `None` means the font is used in isolation, so you are
+    guaranteed to be drawing with the TTF file resolved by :attr:`font_name`.
+    Specifying a value here will load the font file into a named context,
+    enabling fallback between all fonts in the same context. If a font
+    context is set, you are not guaranteed that rendering will actually use
+    the specified TTF file for all glyphs (Pango will pick the one it
+    thinks is best).
+
+    If Kivy is linked against a system-wide installation of FontConfig,
+    you can load the system fonts by specifying a font context starting
+    with the special string `system://`. This will load the system
+    fontconfig configuration, and add your application-specific fonts on
+    top of it (this imposes a signifficant risk of family name collision,
+    Pango may not use your custom font file, but pick one from the system)
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. versionadded:: 1.11.0
+
+    :attr:`font_context` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    font_family = StringProperty(None, allownone=True)
+    '''Font family, this is only applicable when using :attr:`font_context`
+    option. The specified font family will be requested, but note that it may
+    not be available, or there could be multiple fonts registered with the
+    same family. The value can be a family name (string) available in the
+    font context (for example a system font in a `system://` context, or a
+    custom font file added using :class:`kivy.core.text.FontContextManager`).
+    If set to `None`, font selection is controlled by the :attr:`font_name`
+    setting.
+
+    .. note::
+        If using :attr:`font_name` to reference a custom font file, you
+        should leave this as `None`. The family name is managed automatically
+        in this case.
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. versionadded:: 1.11.0
+
+    :attr:`font_family` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    font_name = StringProperty(DEFAULT_FONT)
+    '''Filename of the font to use. The path can be absolute or relative.
+    Relative paths are resolved by the :func:`~kivy.resources.resource_find`
+    function.
+
+    .. warning::
+
+        Depending of your text provider, the font file can be ignored. However,
+        you can mostly use this without problems.
+
+        If the font used lacks the glyphs for the particular language/symbols
+        you are using, you will see '[]' blank box characters instead of the
+        actual glyphs. The solution is to use a font that has the glyphs you
+        need to display. For example, to display |unicodechar|, use a font such
+        as freesans.ttf that has the glyph.
+
+        .. |unicodechar| image:: images/unicode-char.png
+
+    :attr:`font_name` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'Roboto'. This value is taken
+    from :class:`~kivy.config.Config`.
+    '''
+
+    font_size = NumericProperty('15sp')
+    '''Font size of the text, in pixels.
+
+    :attr:`font_size` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 15sp.
+    '''
+
+    font_features = StringProperty()
+    '''OpenType font features, in CSS format, this is passed straight
+    through to Pango. The effects of requesting a feature depends on loaded
+    fonts, library versions, etc. For a complete list of features, see:
+
+    https://en.wikipedia.org/wiki/List_of_typographic_features
+
+    .. note::
+        This feature requires the Pango text provider, and Pango library
+        v1.38 or later.
+
+    .. versionadded:: 1.11.0
+
+    :attr:`font_features` is a :class:`~kivy.properties.StringProperty` and
+    defaults to an empty string.
+    '''
+
+    line_height = NumericProperty(1.0)
+    '''Line Height for the text. e.g. line_height = 2 will cause the spacing
+    between lines to be twice the size.
+
+    :attr:`line_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.0.
+
+    .. versionadded:: 1.5.0
+    '''
+
+    bold = BooleanProperty(False)
+    '''Indicates use of the bold version of your font.
+
+    .. note::
+
+        Depending of your font, the bold attribute may have no impact on your
+        text rendering.
+
+    :attr:`bold` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    italic = BooleanProperty(False)
+    '''Indicates use of the italic version of your font.
+
+    .. note::
+
+        Depending of your font, the italic attribute may have no impact on your
+        text rendering.
+
+    :attr:`italic` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    underline = BooleanProperty(False)
+    '''Adds an underline to the text.
+
+    .. note::
+        This feature requires the SDL2 text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`underline` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    strikethrough = BooleanProperty(False)
+    '''Adds a strikethrough line to the text.
+
+    .. note::
+        This feature requires the SDL2 text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`strikethrough` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    padding_x = NumericProperty(0)
+    '''Horizontal padding of the text inside the widget box.
+
+    :attr:`padding_x` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+
+    .. versionchanged:: 1.9.0
+        `padding_x` has been fixed to work as expected.
+        In the past, the text was padded by the negative of its values.
+    '''
+
+    padding_y = NumericProperty(0)
+    '''Vertical padding of the text inside the widget box.
+
+    :attr:`padding_y` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+
+    .. versionchanged:: 1.9.0
+        `padding_y` has been fixed to work as expected.
+        In the past, the text was padded by the negative of its values.
+    '''
+
+    padding = ReferenceListProperty(padding_x, padding_y)
+    '''Padding of the text in the format (padding_x, padding_y)
+
+    :attr:`padding` is a :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`padding_x`, :attr:`padding_y`) properties.
+    '''
+
+    halign = OptionProperty('auto', options=['left', 'center', 'right',
+                            'justify', 'auto'])
+    '''Horizontal alignment of the text.
+
+    :attr:`halign` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'auto'. Available options are : auto, left, center, right and
+    justify. Auto will attempt to autodetect horizontal alignment for RTL text
+    (Pango only), otherwise it behaves like `left`.
+
+    .. warning::
+
+        This doesn't change the position of the text texture of the Label
+        (centered), only the position of the text in this texture. You probably
+        want to bind the size of the Label to the :attr:`texture_size` or set a
+        :attr:`text_size`.
+
+    .. versionchanged:: 1.10.1
+        Added `auto` option
+
+    .. versionchanged:: 1.6.0
+        A new option was added to :attr:`halign`, namely `justify`.
+    '''
+
+    valign = OptionProperty('bottom',
+                            options=['bottom', 'middle', 'center', 'top'])
+    '''Vertical alignment of the text.
+
+    :attr:`valign` is an :class:`~kivy.properties.OptionProperty` and defaults
+    to 'bottom'. Available options are : `'bottom'`,
+    `'middle'` (or `'center'`) and `'top'`.
+
+    .. versionchanged:: 1.10.0
+        The `'center'` option has been added as an alias of `'middle'`.
+
+    .. warning::
+
+        This doesn't change the position of the text texture of the Label
+        (centered), only the position of the text within this texture. You
+        probably want to bind the size of the Label to the :attr:`texture_size`
+        or set a :attr:`text_size` to change this behavior.
+    '''
+
+    color = ColorProperty([1, 1, 1, 1])
+    '''Text color, in the format (r, g, b, a).
+
+    :attr:`color` is a :class:`~kivy.properties.ColorProperty` and defaults to
+    [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    outline_width = NumericProperty(None, allownone=True)
+    '''Width in pixels for the outline around the text. No outline will be
+    rendered if the value is None.
+
+    .. note::
+        This feature requires the SDL2 text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`outline_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to None.
+    '''
+
+    outline_color = ColorProperty([0, 0, 0, 1])
+    '''The color of the text outline, in the (r, g, b) format.
+
+    .. note::
+        This feature requires the SDL2 text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`outline_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [0, 0, 0, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`. Alpha component is ignored
+        and assigning value to it has no effect.
+    '''
+
+    disabled_outline_color = ColorProperty([0, 0, 0, 1])
+    '''The color of the text outline when the widget is disabled, in the
+    (r, g, b) format.
+
+    .. note::
+        This feature requires the SDL2 text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`disabled_outline_color` is a :class:`~kivy.properties.ColorProperty`
+    and defaults to [0, 0, 0].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`. Alpha component is ignored
+        and assigning value to it has no effect.
+    '''
+
+    texture = ObjectProperty(None, allownone=True)
+    '''Texture object of the text.
+    The text is rendered automatically when a property changes. The OpenGL
+    texture created in this operation is stored in this property. You can use
+    this :attr:`texture` for any graphics elements.
+
+    Depending on the texture creation, the value will be a
+    :class:`~kivy.graphics.texture.Texture` or
+    :class:`~kivy.graphics.texture.TextureRegion` object.
+
+    .. warning::
+
+        The :attr:`texture` update is scheduled for the next frame. If you need
+        the texture immediately after changing a property, you have to call
+        the :meth:`texture_update` method before accessing :attr:`texture`::
+
+            l = Label(text='Hello world')
+            # l.texture is good
+            l.font_size = '50sp'
+            # l.texture is not updated yet
+            l.texture_update()
+            # l.texture is good now.
+
+    :attr:`texture` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    texture_size = ListProperty([0, 0])
+    '''Texture size of the text. The size is determined by the font size and
+    text. If :attr:`text_size` is [None, None], the texture will be the size
+    required to fit the text, otherwise it's clipped to fit :attr:`text_size`.
+
+    When :attr:`text_size` is [None, None], one can bind to texture_size
+    and rescale it proportionally to fit the size of the label in order to
+    make the text fit maximally in the label.
+
+    .. warning::
+
+        The :attr:`texture_size` is set after the :attr:`texture`
+        property. If you listen for changes to :attr:`texture`,
+        :attr:`texture_size` will not be up-to-date in your callback.
+        Bind to :attr:`texture_size` instead.
+    '''
+
+    mipmap = BooleanProperty(False)
+    '''Indicates whether OpenGL mipmapping is applied to the texture or not.
+    Read :ref:`mipmap` for more information.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`mipmap` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    shorten = BooleanProperty(False)
+    '''
+    Indicates whether the label should attempt to shorten its textual contents
+    as much as possible if a :attr:`text_size` is given. Setting this to True
+    without an appropriately set :attr:`text_size` will lead to unexpected
+    results.
+
+    :attr:`shorten_from` and :attr:`split_str` control the direction from
+    which the :attr:`text` is split, as well as where in the :attr:`text` we
+    are allowed to split.
+
+    :attr:`shorten` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    shorten_from = OptionProperty('center', options=['left', 'center',
+                                                     'right'])
+    '''The side from which we should shorten the text from, can be left,
+    right, or center.
+
+    For example, if left, the ellipsis will appear towards the left side and we
+    will display as much text starting from the right as possible. Similar to
+    :attr:`shorten`, this option only applies when :attr:`text_size` [0] is
+    not None, In this case, the string is shortened to fit within the specified
+    width.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`shorten_from` is a :class:`~kivy.properties.OptionProperty` and
+    defaults to `center`.
+    '''
+
+    is_shortened = BooleanProperty(False)
+    '''This property indicates if :attr:`text` was rendered with or without
+    shortening when :attr:`shorten` is True.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`is_shortened` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    split_str = StringProperty('')
+    '''The string used to split the :attr:`text` while shortening the string
+    when :attr:`shorten` is True.
+
+    For example, if it's a space, the string will be broken into words and as
+    many whole words that can fit into a single line will be displayed. If
+    :attr:`split_str` is the empty string, `''`, we split on every character
+    fitting as much text as possible into the line.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`split_str` is a :class:`~kivy.properties.StringProperty` and
+    defaults to `''` (the empty string).
+    '''
+
+    ellipsis_options = DictProperty({})
+    '''Font options for the ellipsis string('...') used to split the text.
+
+    Accepts a dict as option name with the value. Only applied when
+    :attr:`markup` is true and text is shortened. All font options which work
+    for :class:`Label` will work for :attr:`ellipsis_options`. Defaults for
+    the options not specified are taken from the surronding text.
+
+    .. code-block:: kv
+
+        Label:
+            text: 'Some very long line which will be cut'
+            markup: True
+            shorten: True
+            ellipsis_options: {'color':(1,0.5,0.5,1),'underline':True}
+
+    .. versionadded:: 2.0.0
+
+    :attr:`ellipsis_options` is a :class:`~kivy.properties.DictProperty` and
+    defaults to `{}` (the empty dict).
+    '''
+
+    unicode_errors = OptionProperty(
+        'replace', options=('strict', 'replace', 'ignore'))
+    '''How to handle unicode decode errors. Can be `'strict'`, `'replace'` or
+    `'ignore'`.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`unicode_errors` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to `'replace'`.
+    '''
+
+    markup = BooleanProperty(False)
+    '''
+    .. versionadded:: 1.1.0
+
+    If True, the text will be rendered using the
+    :class:`~kivy.core.text.markup.MarkupLabel`: you can change the
+    style of the text using tags. Check the
+    :doc:`api-kivy.core.text.markup` documentation for more information.
+
+    :attr:`markup` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    refs = DictProperty({})
+    '''
+    .. versionadded:: 1.1.0
+
+    List of ``[ref=xxx]`` markup items in the text with the bounding box of
+    all the words contained in a ref, available only after rendering.
+
+    For example, if you wrote::
+
+        Check out my [ref=hello]link[/ref]
+
+    The refs will be set with::
+
+        {'hello': ((64, 0, 78, 16), )}
+
+    The references marked "hello" have a bounding box at (x1, y1, x2, y2).
+    These coordinates are relative to the top left corner of the text, with
+    the y value increasing downwards. You can define multiple refs with the
+    same name: each occurrence will be added as another (x1, y1, x2, y2) tuple
+    to this list.
+
+    The current Label implementation uses these references if they exist in
+    your markup text, automatically doing the collision with the touch and
+    dispatching an `on_ref_press` event.
+
+    You can bind a ref event like this::
+
+        def print_it(instance, value):
+            print('User click on', value)
+        widget = Label(text='Hello [ref=world]World[/ref]', markup=True)
+        widget.bind(on_ref_press=print_it)
+
+    .. note::
+
+        This works only with markup text. You need :attr:`markup` set to
+        True.
+    '''
+
+    anchors = DictProperty({})
+    '''
+    .. versionadded:: 1.1.0
+
+    Position of all the ``[anchor=xxx]`` markup in the text.
+    These coordinates are relative to the top left corner of the text, with
+    the y value increasing downwards. Anchors names should be unique and only
+    the first occurrence of any duplicate anchors will be recorded.
+
+
+    You can place anchors in your markup text as follows::
+
+        text = """
+            [anchor=title1][size=24]This is my Big title.[/size]
+            [anchor=content]Hello world
+        """
+
+    Then, all the ``[anchor=]`` references will be removed and you'll get all
+    the anchor positions in this property (only after rendering)::
+
+        >>> widget = Label(text=text, markup=True)
+        >>> widget.texture_update()
+        >>> widget.anchors
+        {"content": (20, 32), "title1": (20, 16)}
+
+    .. note::
+
+        This works only with markup text. You need :attr:`markup` set to
+        True.
+
+    '''
+
+    max_lines = NumericProperty(0)
+    '''Maximum number of lines to use, defaults to 0, which means unlimited.
+    Please note that :attr:`shorten` take over this property. (with
+    shorten, the text is always one line.)
+
+    .. versionadded:: 1.8.0
+
+    :attr:`max_lines` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    strip = BooleanProperty(False)
+    '''Whether leading and trailing spaces and newlines should be stripped from
+    each displayed line. If True, every line will start at the right or left
+    edge, depending on :attr:`halign`. If :attr:`halign` is `justify` it is
+    implicitly True.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`strip` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    font_hinting = OptionProperty(
+        'normal', options=[None, 'normal', 'light', 'mono'], allownone=True)
+    '''What hinting option to use for font rendering.
+    Can be one of `'normal'`, `'light'`, `'mono'` or None.
+
+    .. note::
+        This feature requires SDL2 or Pango text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`font_hinting` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to `'normal'`.
+    '''
+
+    font_kerning = BooleanProperty(True)
+    '''Whether kerning is enabled for font rendering. You should normally
+    only disable this if rendering is broken with a particular font file.
+
+    .. note::
+        This feature requires the SDL2 text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`font_kerning` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    font_blended = BooleanProperty(True)
+    '''Whether blended or solid font rendering should be used.
+
+    .. note::
+        This feature requires the SDL2 text provider.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`font_blended` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
diff --git a/kivy/uix/layout.py b/kivy/uix/layout.py
new file mode 100644
index 0000000..2dbba89
--- /dev/null
+++ b/kivy/uix/layout.py
@@ -0,0 +1,322 @@
+'''
+Layout
+======
+
+Layouts are used to calculate and assign widget positions.
+
+The :class:`Layout` class itself cannot be used directly.
+You should use one of the following layout classes:
+
+- Anchor layout: :class:`kivy.uix.anchorlayout.AnchorLayout`
+- Box layout: :class:`kivy.uix.boxlayout.BoxLayout`
+- Float layout: :class:`kivy.uix.floatlayout.FloatLayout`
+- Grid layout: :class:`kivy.uix.gridlayout.GridLayout`
+- Page Layout: :class:`kivy.uix.pagelayout.PageLayout`
+- Relative layout: :class:`kivy.uix.relativelayout.RelativeLayout`
+- Scatter layout: :class:`kivy.uix.scatterlayout.ScatterLayout`
+- Stack layout: :class:`kivy.uix.stacklayout.StackLayout`
+
+
+Understanding the `size_hint` Property in `Widget`
+--------------------------------------------------
+
+The :attr:`~kivy.uix.Widget.size_hint` is a tuple of values used by
+layouts to manage the sizes of their children. It indicates the size
+relative to the layout's size instead of an absolute size (in
+pixels/points/cm/etc). The format is::
+
+    widget.size_hint = (width_proportion, height_proportion)
+
+The proportions are specified as floating point numbers in the range 0-1. For
+example, 0.5 represents 50%, 1 represents 100%.
+
+If you want a widget's width to be half of the parent's width and the
+height to be identical to the parent's height, you would do::
+
+    widget.size_hint = (0.5, 1.0)
+
+If you don't want to use a size_hint for either the width or height, set the
+value to None. For example, to make a widget that is 250px wide and 30%
+of the parent's height, do::
+
+    widget.size_hint = (None, 0.3)
+    widget.width = 250
+
+Being :class:`Kivy properties <kivy.properties>`, these can also be set via
+constructor arguments::
+
+    widget = Widget(size_hint=(None, 0.3), width=250)
+
+.. versionchanged:: 1.4.1
+    The `reposition_child` internal method (made public by mistake) has
+    been removed.
+
+'''
+
+__all__ = ('Layout', )
+
+from kivy.clock import Clock
+from kivy.uix.widget import Widget
+from kivy.compat import isclose
+
+
+class Layout(Widget):
+    '''Layout interface class, used to implement every layout. See module
+    documentation for more information.
+    '''
+
+    _trigger_layout = None
+
+    def __init__(self, **kwargs):
+        if self.__class__ == Layout:
+            raise Exception('The Layout class is abstract and \
+                cannot be used directly.')
+        if self._trigger_layout is None:
+            self._trigger_layout = Clock.create_trigger(self.do_layout, -1)
+        super(Layout, self).__init__(**kwargs)
+
+    def do_layout(self, *largs):
+        '''This function is called when a layout is called by a trigger.
+        If you are writing a new Layout subclass, don't call this function
+        directly but use :meth:`_trigger_layout` instead.
+
+        The function is by default called *before* the next frame, therefore
+        the layout isn't updated immediately. Anything depending on the
+        positions of e.g. children should be scheduled for the next frame.
+
+        .. versionadded:: 1.0.8
+        '''
+        raise NotImplementedError('Must be implemented in subclasses.')
+
+    def add_widget(self, widget, *args, **kwargs):
+        fbind = widget.fbind
+        fbind('size', self._trigger_layout)
+        fbind('size_hint', self._trigger_layout)
+        fbind('size_hint_max', self._trigger_layout)
+        fbind('size_hint_min', self._trigger_layout)
+        super(Layout, self).add_widget(widget, *args, **kwargs)
+
+    def remove_widget(self, widget, *args, **kwargs):
+        funbind = widget.funbind
+        funbind('size', self._trigger_layout)
+        funbind('size_hint', self._trigger_layout)
+        funbind('size_hint_max', self._trigger_layout)
+        funbind('size_hint_min', self._trigger_layout)
+        super(Layout, self).remove_widget(widget, *args, **kwargs)
+
+    def layout_hint_with_bounds(
+            self, sh_sum, available_space, min_bounded_size, sh_min_vals,
+            sh_max_vals, hint):
+        '''(internal) Computes the appropriate (size) hint for all the
+        widgets given (potential) min or max bounds on the widgets' size.
+        The ``hint`` list is updated with appropriate sizes.
+
+        It walks through the hints and for any widgets whose hint will result
+        in violating min or max constraints, it fixes the hint. Any remaining
+        or missing space after all the widgets are fixed get distributed
+        to the widgets making them smaller or larger according to their
+        size hint.
+
+        This algorithms knows nothing about the widgets other than what is
+        passed through the input params, so it's fairly generic for laying
+        things out according to constraints using size hints.
+
+        :Parameters:
+
+            `sh_sum`: float
+                The sum of the size hints (basically ``sum(size_hint)``).
+            `available_space`: float
+                The amount of pixels available for all the widgets
+                whose size hint is not None. Cannot be zero.
+            `min_bounded_size`: float
+                The minimum amount of space required according to the
+                `size_hint_min` of the widgets (basically
+                ``sum(size_hint_min)``).
+            `sh_min_vals`: list or iterable
+                Items in the iterable are the size_hint_min for each widget.
+                Can be None. The length should be the same as ``hint``
+            `sh_max_vals`: list or iterable
+                Items in the iterable are the size_hint_max for each widget.
+                Can be None. The length should be the same as ``hint``
+            `hint`: list
+                A list whose size is the same as the length of ``sh_min_vals``
+                and ``sh_min_vals`` whose each element is the corresponding
+                size hint value of that element. This list is updated in place
+                with correct size hints that ensure the constraints are not
+                violated.
+
+        :returns:
+            Nothing. ``hint`` is updated in place.
+        '''
+        if not sh_sum:
+            return
+        # TODO: test when children have size_hint, max/min of zero
+
+        # all divs are float denominator ;)
+        stretch_ratio = sh_sum / float(available_space)
+        if available_space <= min_bounded_size or \
+                isclose(available_space, min_bounded_size):
+            # too small, just set to min
+            for i, (sh, sh_min) in enumerate(zip(hint, sh_min_vals)):
+                if sh is None:
+                    continue
+
+                if sh_min is not None:
+                    hint[i] = sh_min * stretch_ratio  # set to min size
+                else:
+                    hint[i] = 0.  # everything else is zero
+            return
+
+        # these dicts take i (widget child) as key
+        not_mined_contrib = {}  # all who's sh > min_sh or had no min_sh
+        not_maxed_contrib = {}  # all who's sh < max_sh or had no max_sh
+        sh_mins_avail = {}  # the sh amt removable until we hit sh_min
+        sh_maxs_avail = {}  # the sh amt addable until we hit sh_max
+        oversize_amt = undersize_amt = 0
+        hint_orig = hint[:]
+
+        # first, for all the items, set them to be within their max/min
+        # size_hint bound, also find how much their size_hint can be reduced
+        # or increased
+        for i, (sh, sh_min, sh_max) in enumerate(
+                zip(hint, sh_min_vals, sh_max_vals)):
+            if sh is None:
+                continue
+
+            diff = 0
+
+            if sh_min is not None:
+                sh_min *= stretch_ratio
+                diff = sh_min - sh  # how much we are under the min
+
+                if diff > 0:
+                    hint[i] = sh_min
+                    undersize_amt += diff
+                else:
+                    not_mined_contrib[i] = None
+
+                sh_mins_avail[i] = hint[i] - sh_min
+            else:
+                not_mined_contrib[i] = None
+                sh_mins_avail[i] = hint[i]
+
+            if sh_max is not None:
+                sh_max *= stretch_ratio
+                diff = sh - sh_max
+
+                if diff > 0:
+                    hint[i] = sh_max  # how much we are over the max
+                    oversize_amt += diff
+                else:
+                    not_maxed_contrib[i] = None
+
+                sh_maxs_avail[i] = sh_max - hint[i]
+            else:
+                not_maxed_contrib[i] = None
+                sh_maxs_avail[i] = sh_sum - hint[i]
+
+            if i in not_mined_contrib:
+                not_mined_contrib[i] = max(0., diff)  # how much got removed
+            if i in not_maxed_contrib:
+                not_maxed_contrib[i] = max(0., diff)  # how much got added
+
+        # if margin is zero, the amount of the widgets that were made smaller
+        # magically equals the amount of the widgets that were made larger
+        # so we're all good
+        margin = oversize_amt - undersize_amt
+        if isclose(oversize_amt, undersize_amt, abs_tol=1e-15):
+            return
+
+        # we need to redistribute the margin among all widgets
+        # if margin is positive, then we have extra space because the widgets
+        # that were larger and were reduced contributed more, so increase
+        # the size hint for those that are allowed to be larger by the
+        # most allowed, proportionately to their size (or inverse size hint).
+        # similarly for the opposite case
+        if margin > 1e-15:
+            contrib_amt = not_maxed_contrib
+            sh_available = sh_maxs_avail
+            mult = 1.
+            contrib_proportion = hint_orig
+        elif margin < -1e-15:
+            margin *= -1.
+            contrib_amt = not_mined_contrib
+            sh_available = sh_mins_avail
+            mult = -1.
+
+            # when reducing the size of widgets proportionately, those with
+            # larger sh get reduced less, and those with smaller, more.
+            mn = min((h for h in hint_orig if h))
+            mx = max((h for h in hint_orig if h is not None))
+            hint_top = (2. * mn if mn else 1.) if mn == mx else mn + mx
+            contrib_proportion = [None if h is None else hint_top - h for
+                          h in hint_orig]
+
+        # contrib_amt is all the widgets that are not their max/min and
+        # can afford to be made bigger/smaller
+        # We only use the contrib_amt indices from now on
+        contrib_prop_sum = float(
+            sum((contrib_proportion[i] for i in contrib_amt)))
+
+        if contrib_prop_sum < 1e-9:
+            assert mult == 1.  # should only happen when all sh are zero
+            return
+
+        contrib_height = {
+            i: val / (contrib_proportion[i] / contrib_prop_sum) for
+            i, val in contrib_amt.items()}
+        items = sorted(
+            (i for i in contrib_amt),
+            key=lambda x: contrib_height[x])
+
+        j = items[0]
+        sum_i_contributed = contrib_amt[j]
+        last_height = contrib_height[j]
+        sh_available_i = {j: sh_available[j]}
+        contrib_prop_sum_i = contrib_proportion[j]
+
+        n = len(items)  # check when n <= 1
+        i = 1
+        if 1 < n:
+            j = items[1]
+            curr_height = contrib_height[j]
+
+        done = False
+        while not done and i < n:
+            while i < n and last_height == curr_height:
+                j = items[i]
+                sum_i_contributed += contrib_amt[j]
+                contrib_prop_sum_i += contrib_proportion[j]
+                sh_available_i[j] = sh_available[j]
+                curr_height = contrib_height[j]
+                i += 1
+            last_height = curr_height
+
+            while not done:
+                margin_height = ((margin + sum_i_contributed) /
+                                 (contrib_prop_sum_i / contrib_prop_sum))
+                if margin_height - curr_height > 1e-9 and i < n:
+                    break
+
+                done = True
+                for k, available_sh in list(sh_available_i.items()):
+                    if margin_height - available_sh / (
+                            contrib_proportion[k] / contrib_prop_sum) > 1e-9:
+                        del sh_available_i[k]
+                        sum_i_contributed -= contrib_amt[k]
+                        contrib_prop_sum_i -= contrib_proportion[k]
+                        margin -= available_sh
+                        hint[k] += mult * available_sh
+                        done = False
+
+                if not sh_available_i:  # all were under the margin
+                    break
+
+        if sh_available_i:
+            assert contrib_prop_sum_i and margin
+            margin_height = ((margin + sum_i_contributed) /
+                             (contrib_prop_sum_i / contrib_prop_sum))
+            for i in sh_available_i:
+                hint[i] += mult * (
+                    margin_height * contrib_proportion[i] / contrib_prop_sum -
+                    contrib_amt[i])
diff --git a/kivy/uix/modalview.py b/kivy/uix/modalview.py
new file mode 100644
index 0000000..4cf674d
--- /dev/null
+++ b/kivy/uix/modalview.py
@@ -0,0 +1,339 @@
+"""
+ModalView
+=========
+
+.. versionadded:: 1.4.0
+
+The :class:`ModalView` widget is used to create modal views. By default, the
+view will cover the whole "main" window.
+
+Remember that the default size of a Widget is size_hint=(1, 1). If you don't
+want your view to be fullscreen, either use size hints with values lower than
+1 (for instance size_hint=(.8, .8)) or deactivate the size_hint and use fixed
+size attributes.
+
+Examples
+--------
+
+Example of a simple 400x400 Hello world view::
+
+    view = ModalView(size_hint=(None, None), size=(400, 400))
+    view.add_widget(Label(text='Hello world'))
+
+By default, any click outside the view will dismiss it. If you don't
+want that, you can set :attr:`ModalView.auto_dismiss` to False::
+
+    view = ModalView(auto_dismiss=False)
+    view.add_widget(Label(text='Hello world'))
+    view.open()
+
+To manually dismiss/close the view, use the :meth:`ModalView.dismiss` method of
+the ModalView instance::
+
+    view.dismiss()
+
+Both :meth:`ModalView.open` and :meth:`ModalView.dismiss` are bind-able. That
+means you can directly bind the function to an action, e.g. to a button's
+on_press ::
+
+    # create content and add it to the view
+    content = Button(text='Close me!')
+    view = ModalView(auto_dismiss=False)
+    view.add_widget(content)
+
+    # bind the on_press event of the button to the dismiss function
+    content.bind(on_press=view.dismiss)
+
+    # open the view
+    view.open()
+
+
+ModalView Events
+----------------
+
+There are four events available: `on_pre_open` and `on_open` which are raised
+when the view is opening; `on_pre_dismiss` and `on_dismiss` which are raised
+when the view is closed.
+
+For `on_dismiss`, you can prevent the view from closing by explicitly
+returning `True` from your callback::
+
+    def my_callback(instance):
+        print('ModalView', instance, 'is being dismissed, but is prevented!')
+        return True
+    view = ModalView()
+    view.add_widget(Label(text='Hello world'))
+    view.bind(on_dismiss=my_callback)
+    view.open()
+
+
+.. versionchanged:: 1.5.0
+    The ModalView can be closed by hitting the escape key on the
+    keyboard if the :attr:`ModalView.auto_dismiss` property is True (the
+    default).
+
+"""
+
+__all__ = ('ModalView', )
+
+from kivy.animation import Animation
+from kivy.properties import (
+    StringProperty, BooleanProperty, ObjectProperty, NumericProperty,
+    ListProperty, ColorProperty)
+from kivy.uix.anchorlayout import AnchorLayout
+
+
+class ModalView(AnchorLayout):
+    """ModalView class. See module documentation for more information.
+
+    :Events:
+        `on_pre_open`:
+            Fired before the ModalView is opened. When this event is fired
+            ModalView is not yet added to window.
+        `on_open`:
+            Fired when the ModalView is opened.
+        `on_pre_dismiss`:
+            Fired before the ModalView is closed.
+        `on_dismiss`:
+            Fired when the ModalView is closed. If the callback returns True,
+            the dismiss will be canceled.
+
+    .. versionchanged:: 1.11.0
+        Added events `on_pre_open` and `on_pre_dismiss`.
+
+    .. versionchanged:: 2.0.0
+        Added property 'overlay_color'.
+
+    .. versionchanged:: 2.1.0
+        Marked `attach_to` property as deprecated.
+
+    """
+
+    # noinspection PyArgumentEqualDefault
+    auto_dismiss = BooleanProperty(True)
+    '''This property determines if the view is automatically
+    dismissed when the user clicks outside it.
+
+    :attr:`auto_dismiss` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    attach_to = ObjectProperty(None, deprecated=True)
+    '''If a widget is set on attach_to, the view will attach to the nearest
+    parent window of the widget. If none is found, it will attach to the
+    main/global Window.
+
+    :attr:`attach_to` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''Background color, in the format (r, g, b, a).
+
+    This acts as a *multiplier* to the texture colour. The default
+    texture is grey, so just setting the background color will give
+    a darker result. To set a plain color, set the
+    :attr:`background_normal` to ``''``.
+
+    The :attr:`background_color` is a
+    :class:`~kivy.properties.ColorProperty` and defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed behavior to affect the background of the widget itself, not
+        the overlay dimming.
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    background = StringProperty(
+        'atlas://data/images/defaulttheme/modalview-background')
+    '''Background image of the view used for the view background.
+
+    :attr:`background` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/modalview-background'.
+    '''
+
+    border = ListProperty([16, 16, 16, 16])
+    '''Border used for :class:`~kivy.graphics.vertex_instructions.BorderImage`
+    graphics instruction. Used for the :attr:`background_normal` and the
+    :attr:`background_down` properties. Can be used when using custom
+    backgrounds.
+
+    It must be a list of four values: (bottom, right, top, left). Read the
+    BorderImage instructions for more information about how to use it.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and defaults to
+    (16, 16, 16, 16).
+    '''
+
+    overlay_color = ColorProperty([0, 0, 0, .7])
+    '''Overlay color in the format (r, g, b, a).
+    Used for dimming the window behind the modal view.
+
+    :attr:`overlay_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [0, 0, 0, .7].
+
+    .. versionadded:: 2.0.0
+    '''
+
+    # Internals properties used for graphical representation.
+
+    _anim_alpha = NumericProperty(0)
+
+    _anim_duration = NumericProperty(.1)
+
+    _window = ObjectProperty(allownone=True, rebind=True)
+
+    _is_open = BooleanProperty(False)
+
+    _touch_started_inside = None
+
+    __events__ = ('on_pre_open', 'on_open', 'on_pre_dismiss', 'on_dismiss')
+
+    def __init__(self, **kwargs):
+        self._parent = None
+        super(ModalView, self).__init__(**kwargs)
+
+    def open(self, *_args, **kwargs):
+        """Display the modal in the Window.
+
+        When the view is opened, it will be faded in with an animation. If you
+        don't want the animation, use::
+
+            view.open(animation=False)
+
+        """
+        from kivy.core.window import Window
+        if self._is_open:
+            return
+        self._window = Window
+        self._is_open = True
+        self.dispatch('on_pre_open')
+        Window.add_widget(self)
+        Window.bind(
+            on_resize=self._align_center,
+            on_keyboard=self._handle_keyboard)
+        self.center = Window.center
+        self.fbind('center', self._align_center)
+        self.fbind('size', self._align_center)
+        if kwargs.get('animation', True):
+            ani = Animation(_anim_alpha=1., d=self._anim_duration)
+            ani.bind(on_complete=lambda *_args: self.dispatch('on_open'))
+            ani.start(self)
+        else:
+            self._anim_alpha = 1.
+            self.dispatch('on_open')
+
+    def dismiss(self, *_args, **kwargs):
+        """ Close the view if it is open.
+
+        If you really want to close the view, whatever the on_dismiss
+        event returns, you can use the *force* keyword argument::
+
+            view = ModalView()
+            view.dismiss(force=True)
+
+        When the view is dismissed, it will be faded out before being
+        removed from the parent. If you don't want this animation, use::
+
+            view.dismiss(animation=False)
+
+        """
+        if not self._is_open:
+            return
+        self.dispatch('on_pre_dismiss')
+        if self.dispatch('on_dismiss') is True:
+            if kwargs.get('force', False) is not True:
+                return
+        if kwargs.get('animation', True):
+            Animation(_anim_alpha=0., d=self._anim_duration).start(self)
+        else:
+            self._anim_alpha = 0
+            self._real_remove_widget()
+
+    def _align_center(self, *_args):
+        if self._is_open:
+            self.center = self._window.center
+
+    def on_motion(self, etype, me):
+        super().on_motion(etype, me)
+        return True
+
+    def on_touch_down(self, touch):
+        """ touch down event handler. """
+        self._touch_started_inside = self.collide_point(*touch.pos)
+        if not self.auto_dismiss or self._touch_started_inside:
+            super().on_touch_down(touch)
+        return True
+
+    def on_touch_move(self, touch):
+        """ touch moved event handler. """
+        if not self.auto_dismiss or self._touch_started_inside:
+            super().on_touch_move(touch)
+        return True
+
+    def on_touch_up(self, touch):
+        """ touch up event handler. """
+        # Explicitly test for False as None occurs when shown by on_touch_down
+        if self.auto_dismiss and self._touch_started_inside is False:
+            self.dismiss()
+        else:
+            super().on_touch_up(touch)
+        self._touch_started_inside = None
+        return True
+
+    def on__anim_alpha(self, _instance, value):
+        """ animation progress callback. """
+        if value == 0 and self._is_open:
+            self._real_remove_widget()
+
+    def _real_remove_widget(self):
+        if not self._is_open:
+            return
+        self._window.remove_widget(self)
+        self._window.unbind(
+            on_resize=self._align_center,
+            on_keyboard=self._handle_keyboard)
+        self._is_open = False
+        self._window = None
+
+    def on_pre_open(self):
+        """ default pre-open event handler. """
+
+    def on_open(self):
+        """ default open event handler. """
+
+    def on_pre_dismiss(self):
+        """ default pre-dismiss event handler. """
+
+    def on_dismiss(self):
+        """ default dismiss event handler. """
+
+    def _handle_keyboard(self, _window, key, *_args):
+        if key == 27 and self.auto_dismiss:
+            self.dismiss()
+            return True
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    from kivy.uix.button import Button
+    from kivy.core.window import Window
+    from kivy.uix.label import Label
+    from kivy.uix.gridlayout import GridLayout
+
+    # add view
+    content = GridLayout(cols=1)
+    content.add_widget(Label(text='This is a hello world'))
+    view = ModalView(size_hint=(None, None), size=(256, 256))
+    view.add_widget(content)
+
+    layout = GridLayout(cols=3)
+    for x in range(9):
+        btn = Button(text=f"click me {x}")
+        btn.bind(on_release=view.open)
+        layout.add_widget(btn)
+    Window.add_widget(layout)
+
+    view.open()
+    runTouchApp()
diff --git a/kivy/uix/pagelayout.py b/kivy/uix/pagelayout.py
new file mode 100644
index 0000000..6319d28
--- /dev/null
+++ b/kivy/uix/pagelayout.py
@@ -0,0 +1,233 @@
+"""
+PageLayout
+==========
+
+.. image:: images/pagelayout.gif
+    :align: right
+
+The :class:`PageLayout` class is used to create a simple multi-page
+layout, in a way that allows easy flipping from one page to another using
+borders.
+
+:class:`PageLayout` does not currently honor the
+:attr:`~kivy.uix.widget.Widget.size_hint`,
+:attr:`~kivy.uix.widget.Widget.size_hint_min`,
+:attr:`~kivy.uix.widget.Widget.size_hint_max`, or
+:attr:`~kivy.uix.widget.Widget.pos_hint` properties.
+
+.. versionadded:: 1.8.0
+
+Example:
+
+.. code-block:: kv
+
+    PageLayout:
+        Button:
+            text: 'page1'
+        Button:
+            text: 'page2'
+        Button:
+            text: 'page3'
+
+Transitions from one page to the next are made by swiping in from the border
+areas on the right or left hand side. If you wish to display multiple widgets
+in a page, we suggest you use a containing layout. Ideally, each page should
+consist of a single :mod:`~kivy.uix.layout` widget that contains the remaining
+widgets on that page.
+"""
+
+__all__ = ('PageLayout', )
+
+from kivy.uix.layout import Layout
+from kivy.properties import NumericProperty, DictProperty
+from kivy.animation import Animation
+
+
+class PageLayout(Layout):
+    '''PageLayout class. See module documentation for more information.
+    '''
+
+    page = NumericProperty(0)
+    '''The currently displayed page.
+
+    :data:`page` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0.
+    '''
+
+    border = NumericProperty('50dp')
+    '''The width of the border around the current page used to display
+    the previous/next page swipe areas when needed.
+
+    :data:`border` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 50dp.
+    '''
+
+    swipe_threshold = NumericProperty(.5)
+    '''The threshold used to trigger swipes as ratio of the widget
+    size.
+
+    :data:`swipe_threshold` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to .5.
+    '''
+
+    anim_kwargs = DictProperty({'d': .5, 't': 'in_quad'})
+    '''The animation kwargs used to construct the animation
+
+    :data:`anim_kwargs` is a :class:`~kivy.properties.DictProperty`
+    and defaults to {'d': .5, 't': 'in_quad'}.
+
+    .. versionadded:: 1.11.0
+    '''
+
+    def __init__(self, **kwargs):
+        super(PageLayout, self).__init__(**kwargs)
+
+        trigger = self._trigger_layout
+        fbind = self.fbind
+        fbind('border', trigger)
+        fbind('page', trigger)
+        fbind('parent', trigger)
+        fbind('children', trigger)
+        fbind('size', trigger)
+        fbind('pos', trigger)
+
+    def do_layout(self, *largs):
+        l_children = len(self.children) - 1
+        h = self.height
+        x_parent, y_parent = self.pos
+        p = self.page
+        border = self.border
+        half_border = border / 2.
+        right = self.right
+        width = self.width - border
+        for i, c in enumerate(reversed(self.children)):
+
+            if i < p:
+                x = x_parent
+            elif i == p:
+                if not p:  # it's first page
+                    x = x_parent
+                elif p != l_children:  # not first, but there are post pages
+                    x = x_parent + half_border
+                else:  # not first and there are no post pages
+                    x = x_parent + border
+            elif i == p + 1:
+                if not p:  # second page - no left margin
+                    x = right - border
+                else:  # there's already a left margin
+                    x = right - half_border
+            else:
+                x = right
+
+            c.height = h
+            c.width = width
+
+            Animation(
+                x=x,
+                y=y_parent,
+                **self.anim_kwargs).start(c)
+
+    def on_touch_down(self, touch):
+        if (
+            self.disabled or
+            not self.collide_point(*touch.pos) or
+            not self.children
+        ):
+            return
+
+        page = self.children[-self.page - 1]
+        if self.x <= touch.x < page.x:
+            touch.ud['page'] = 'previous'
+            touch.grab(self)
+            return True
+        elif page.right <= touch.x < self.right:
+            touch.ud['page'] = 'next'
+            touch.grab(self)
+            return True
+        return page.on_touch_down(touch)
+
+    def on_touch_move(self, touch):
+        if touch.grab_current != self:
+            return
+
+        p = self.page
+        border = self.border
+        half_border = border / 2.
+        page = self.children[-p - 1]
+        if touch.ud['page'] == 'previous':
+            # move next page up to right edge
+            if p < len(self.children) - 1:
+                self.children[-p - 2].x = min(
+                    self.right - self.border * (1 - (touch.sx - touch.osx)),
+                    self.right)
+
+            # move current page until edge hits the right border
+            if p >= 1:
+                b_right = half_border if p > 1 else border
+                b_left = half_border if p < len(self.children) - 1 else border
+                self.children[-p - 1].x = max(min(
+                    self.x + b_left + (touch.x - touch.ox),
+                    self.right - b_right),
+                    self.x + b_left)
+
+            # move previous page left edge up to left border
+            if p > 1:
+                self.children[-p].x = min(
+                    self.x + half_border * (touch.sx - touch.osx),
+                    self.x + half_border)
+
+        elif touch.ud['page'] == 'next':
+            # move current page up to left edge
+            if p >= 1:
+                self.children[-p - 1].x = max(
+                    self.x + half_border * (1 - (touch.osx - touch.sx)),
+                    self.x)
+
+            # move next page until its edge hit the left border
+            if p < len(self.children) - 1:
+                b_right = half_border if p >= 1 else border
+                b_left = half_border if p < len(self.children) - 2 else border
+                self.children[-p - 2].x = min(max(
+                    self.right - b_right + (touch.x - touch.ox),
+                    self.x + b_left),
+                    self.right - b_right)
+
+            # move second next page up to right border
+            if p < len(self.children) - 2:
+                self.children[-p - 3].x = max(
+                    self.right + half_border * (touch.sx - touch.osx),
+                    self.right - half_border)
+
+        return page.on_touch_move(touch)
+
+    def on_touch_up(self, touch):
+        if touch.grab_current == self:
+            if (
+                touch.ud['page'] == 'previous' and
+                abs(touch.x - touch.ox) / self.width > self.swipe_threshold
+            ):
+                self.page -= 1
+            elif (
+                touch.ud['page'] == 'next' and
+                abs(touch.x - touch.ox) / self.width > self.swipe_threshold
+            ):
+                self.page += 1
+            else:
+                self._trigger_layout()
+
+            touch.ungrab(self)
+
+        if len(self.children) > 1:
+            return self.children[-self.page + 1].on_touch_up(touch)
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    from kivy.uix.button import Button
+
+    pl = PageLayout()
+    for i in range(1, 4):
+        b = Button(text='page%s' % i)
+        pl.add_widget(b)
+
+    runTouchApp(pl)
diff --git a/kivy/uix/popup.py b/kivy/uix/popup.py
new file mode 100644
index 0000000..0d7d936
--- /dev/null
+++ b/kivy/uix/popup.py
@@ -0,0 +1,266 @@
+'''
+Popup
+=====
+
+.. versionadded:: 1.0.7
+
+.. image:: images/popup.jpg
+    :align: right
+
+The :class:`Popup` widget is used to create modal popups. By default, the popup
+will cover the whole "parent" window. When you are creating a popup, you
+must at least set a :attr:`Popup.title` and :attr:`Popup.content`.
+
+Remember that the default size of a Widget is size_hint=(1, 1). If you don't
+want your popup to be fullscreen, either use size hints with values less than 1
+(for instance size_hint=(.8, .8)) or deactivate the size_hint and use
+fixed size attributes.
+
+
+.. versionchanged:: 1.4.0
+    The :class:`Popup` class now inherits from
+    :class:`~kivy.uix.modalview.ModalView`. The :class:`Popup` offers a default
+    layout with a title and a separation bar.
+
+Examples
+--------
+
+Example of a simple 400x400 Hello world popup::
+
+    popup = Popup(title='Test popup',
+        content=Label(text='Hello world'),
+        size_hint=(None, None), size=(400, 400))
+
+By default, any click outside the popup will dismiss/close it. If you don't
+want that, you can set
+:attr:`~kivy.uix.modalview.ModalView.auto_dismiss` to False::
+
+    popup = Popup(title='Test popup', content=Label(text='Hello world'),
+                  auto_dismiss=False)
+    popup.open()
+
+To manually dismiss/close the popup, use
+:attr:`~kivy.uix.modalview.ModalView.dismiss`::
+
+    popup.dismiss()
+
+Both :meth:`~kivy.uix.modalview.ModalView.open` and
+:meth:`~kivy.uix.modalview.ModalView.dismiss` are bindable. That means you
+can directly bind the function to an action, e.g. to a button's on_press::
+
+    # create content and add to the popup
+    content = Button(text='Close me!')
+    popup = Popup(content=content, auto_dismiss=False)
+
+    # bind the on_press event of the button to the dismiss function
+    content.bind(on_press=popup.dismiss)
+
+    # open the popup
+    popup.open()
+
+Same thing in KV language only with :class:`Factory`:
+
+.. code-block:: kv
+
+    #:import Factory kivy.factory.Factory
+    <MyPopup@Popup>:
+        auto_dismiss: False
+        Button:
+            text: 'Close me!'
+            on_release: root.dismiss()
+
+    Button:
+        text: 'Open popup'
+        on_release: Factory.MyPopup().open()
+
+.. note::
+
+    Popup is a special widget. Don't try to add it as a child to any other
+    widget. If you do, Popup will be handled like an ordinary widget and
+    won't be created hidden in the background.
+
+    .. code-block:: kv
+
+        BoxLayout:
+            MyPopup:  # bad!
+
+Popup Events
+------------
+
+There are two events available: `on_open` which is raised when the popup is
+opening, and `on_dismiss` which is raised when the popup is closed.
+For `on_dismiss`, you can prevent the
+popup from closing by explicitly returning True from your callback::
+
+    def my_callback(instance):
+        print('Popup', instance, 'is being dismissed but is prevented!')
+        return True
+    popup = Popup(content=Label(text='Hello world'))
+    popup.bind(on_dismiss=my_callback)
+    popup.open()
+
+'''
+
+__all__ = ('Popup', 'PopupException')
+
+from kivy.core.text import DEFAULT_FONT
+from kivy.uix.modalview import ModalView
+from kivy.properties import (StringProperty, ObjectProperty, OptionProperty,
+                             NumericProperty, ColorProperty)
+
+
+class PopupException(Exception):
+    '''Popup exception, fired when multiple content widgets are added to the
+    popup.
+
+    .. versionadded:: 1.4.0
+    '''
+
+
+class Popup(ModalView):
+    '''Popup class. See module documentation for more information.
+
+    :Events:
+        `on_open`:
+            Fired when the Popup is opened.
+        `on_dismiss`:
+            Fired when the Popup is closed. If the callback returns True, the
+            dismiss will be canceled.
+    '''
+
+    title = StringProperty('No title')
+    '''String that represents the title of the popup.
+
+    :attr:`title` is a :class:`~kivy.properties.StringProperty` and defaults to
+    'No title'.
+    '''
+
+    title_size = NumericProperty('14sp')
+    '''Represents the font size of the popup title.
+
+    .. versionadded:: 1.6.0
+
+    :attr:`title_size` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to '14sp'.
+    '''
+
+    title_align = OptionProperty(
+        'left', options=['left', 'center', 'right', 'justify'])
+    '''Horizontal alignment of the title.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`title_align` is a :class:`~kivy.properties.OptionProperty` and
+    defaults to 'left'. Available options are left, center, right and justify.
+    '''
+
+    title_font = StringProperty(DEFAULT_FONT)
+    '''Font used to render the title text.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`title_font` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'Roboto'. This value is taken
+    from :class:`~kivy.config.Config`.
+    '''
+
+    content = ObjectProperty(None)
+    '''Content of the popup that is displayed just under the title.
+
+    :attr:`content` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    title_color = ColorProperty([1, 1, 1, 1])
+    '''Color used by the Title.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`title_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    separator_color = ColorProperty([47 / 255., 167 / 255., 212 / 255., 1.])
+    '''Color used by the separator between title and content.
+
+    .. versionadded:: 1.1.0
+
+    :attr:`separator_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [47 / 255., 167 / 255., 212 / 255., 1.].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    separator_height = NumericProperty('2dp')
+    '''Height of the separator.
+
+    .. versionadded:: 1.1.0
+
+    :attr:`separator_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 2dp.
+    '''
+
+    # Internal properties used for graphical representation.
+
+    _container = ObjectProperty(None)
+
+    def add_widget(self, widget, *args, **kwargs):
+        if self._container:
+            if self.content:
+                raise PopupException(
+                    'Popup can have only one widget as content')
+            self.content = widget
+        else:
+            super(Popup, self).add_widget(widget, *args, **kwargs)
+
+    def on_content(self, instance, value):
+        if self._container:
+            self._container.clear_widgets()
+            self._container.add_widget(value)
+
+    def on__container(self, instance, value):
+        if value is None or self.content is None:
+            return
+        self._container.clear_widgets()
+        self._container.add_widget(self.content)
+
+    def on_touch_down(self, touch):
+        if self.disabled and self.collide_point(*touch.pos):
+            return True
+        return super(Popup, self).on_touch_down(touch)
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    from kivy.uix.button import Button
+    from kivy.uix.label import Label
+    from kivy.uix.gridlayout import GridLayout
+    from kivy.core.window import Window
+
+    # add popup
+    content = GridLayout(cols=1)
+    content_cancel = Button(text='Cancel', size_hint_y=None, height=40)
+    content.add_widget(Label(text='This is a hello world'))
+    content.add_widget(content_cancel)
+    popup = Popup(title='Test popup',
+                  size_hint=(None, None), size=(256, 256),
+                  content=content, disabled=True)
+    content_cancel.bind(on_release=popup.dismiss)
+
+    layout = GridLayout(cols=3)
+    for x in range(9):
+        btn = Button(text=str(x))
+        btn.bind(on_release=popup.open)
+        layout.add_widget(btn)
+
+    Window.add_widget(layout)
+
+    popup.open()
+
+    runTouchApp()
diff --git a/kivy/uix/progressbar.py b/kivy/uix/progressbar.py
new file mode 100644
index 0000000..2c3d39f
--- /dev/null
+++ b/kivy/uix/progressbar.py
@@ -0,0 +1,95 @@
+'''
+Progress Bar
+============
+
+.. versionadded:: 1.0.8
+
+.. image:: images/progressbar.jpg
+    :align: right
+
+The :class:`ProgressBar` widget is used to visualize the progress of some task.
+Only the horizontal mode is currently supported: the vertical mode is not
+yet available.
+
+The progress bar has no interactive elements and is a display-only widget.
+
+To use it, simply assign a value to indicate the current progress::
+
+    from kivy.uix.progressbar import ProgressBar
+    pb = ProgressBar(max=1000)
+
+    # this will update the graphics automatically (75% done)
+    pb.value = 750
+
+'''
+
+__all__ = ('ProgressBar', )
+
+from kivy.uix.widget import Widget
+from kivy.properties import NumericProperty, AliasProperty
+
+
+class ProgressBar(Widget):
+    '''Class for creating a progress bar widget.
+
+    See module documentation for more details.
+    '''
+
+    def __init__(self, **kwargs):
+        self._value = 0.
+        super(ProgressBar, self).__init__(**kwargs)
+
+    def _get_value(self):
+        return self._value
+
+    def _set_value(self, value):
+        value = max(0, min(self.max, value))
+        if value != self._value:
+            self._value = value
+            return True
+
+    value = AliasProperty(_get_value, _set_value)
+    '''Current value used for the slider.
+
+    :attr:`value` is an :class:`~kivy.properties.AliasProperty` that
+    returns the value of the progress bar. If the value is < 0 or >
+    :attr:`max`, it will be normalized to those boundaries.
+
+    .. versionchanged:: 1.6.0
+        The value is now limited to between 0 and :attr:`max`.
+    '''
+
+    def get_norm_value(self):
+        d = self.max
+        if d == 0:
+            return 0
+        return self.value / float(d)
+
+    def set_norm_value(self, value):
+        self.value = value * self.max
+
+    value_normalized = AliasProperty(get_norm_value, set_norm_value,
+                                     bind=('value', 'max'), cache=True)
+    '''Normalized value inside the range 0-1::
+
+        >>> pb = ProgressBar(value=50, max=100)
+        >>> pb.value
+        50
+        >>> pb.value_normalized
+        0.5
+
+    :attr:`value_normalized` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    max = NumericProperty(100.)
+    '''Maximum value allowed for :attr:`value`.
+
+    :attr:`max` is a :class:`~kivy.properties.NumericProperty` and defaults to
+    100.
+    '''
+
+
+if __name__ == '__main__':
+
+    from kivy.base import runTouchApp
+    runTouchApp(ProgressBar(value=50))
diff --git a/kivy/uix/recycleboxlayout.py b/kivy/uix/recycleboxlayout.py
new file mode 100644
index 0000000..6215520
--- /dev/null
+++ b/kivy/uix/recycleboxlayout.py
@@ -0,0 +1,183 @@
+"""
+RecycleBoxLayout
+================
+
+.. versionadded:: 1.10.0
+
+.. warning::
+    This module is highly experimental, its API may change in the future and
+    the documentation is not complete at this time.
+
+The RecycleBoxLayout is designed to provide a
+:class:`~kivy.uix.boxlayout.BoxLayout` type layout when used with the
+:class:`~kivy.uix.recycleview.RecycleView` widget. Please refer to the
+:mod:`~kivy.uix.recycleview` module documentation for more information.
+
+"""
+
+from kivy.uix.recyclelayout import RecycleLayout
+from kivy.uix.boxlayout import BoxLayout
+
+__all__ = ('RecycleBoxLayout', )
+
+
+class RecycleBoxLayout(RecycleLayout, BoxLayout):
+
+    _rv_positions = None
+
+    def __init__(self, **kwargs):
+        super(RecycleBoxLayout, self).__init__(**kwargs)
+        self.funbind('children', self._trigger_layout)
+
+    def _update_sizes(self, changed):
+        horizontal = self.orientation == 'horizontal'
+        padding_left, padding_top, padding_right, padding_bottom = self.padding
+        padding_x = padding_left + padding_right
+        padding_y = padding_top + padding_bottom
+        selfw = self.width
+        selfh = self.height
+        layout_w = max(0, selfw - padding_x)
+        layout_h = max(0, selfh - padding_y)
+        cx = self.x + padding_left
+        cy = self.y + padding_bottom
+        view_opts = self.view_opts
+        remove_view = self.remove_view
+
+        for (index, widget, (w, h), (wn, hn), (shw, shh), (shnw, shnh),
+             (shw_min, shh_min), (shwn_min, shhn_min), (shw_max, shh_max),
+             (shwn_max, shhn_max), ph, phn) in changed:
+            if (horizontal and
+                (shw != shnw or w != wn or shw_min != shwn_min or
+                 shw_max != shwn_max) or
+                not horizontal and
+                (shh != shnh or h != hn or shh_min != shhn_min or
+                 shh_max != shhn_max)):
+                return True
+
+            remove_view(widget, index)
+            opt = view_opts[index]
+            if horizontal:
+                wo, ho = opt['size']
+                if shnh is not None:
+                    _, h = opt['size'] = [wo, shnh * layout_h]
+                else:
+                    h = ho
+
+                xo, yo = opt['pos']
+                for key, value in phn.items():
+                    posy = value * layout_h
+                    if key == 'y':
+                        yo = posy + cy
+                    elif key == 'top':
+                        yo = posy - h
+                    elif key == 'center_y':
+                        yo = posy - (h / 2.)
+                opt['pos'] = [xo, yo]
+            else:
+                wo, ho = opt['size']
+                if shnw is not None:
+                    w, _ = opt['size'] = [shnw * layout_w, ho]
+                else:
+                    w = wo
+
+                xo, yo = opt['pos']
+                for key, value in phn.items():
+                    posx = value * layout_w
+                    if key == 'x':
+                        xo = posx + cx
+                    elif key == 'right':
+                        xo = posx - w
+                    elif key == 'center_x':
+                        xo = posx - (w / 2.)
+                opt['pos'] = [xo, yo]
+
+        return False
+
+    def compute_layout(self, data, flags):
+        super(RecycleBoxLayout, self).compute_layout(data, flags)
+
+        changed = self._changed_views
+        if (changed is None or
+                changed and not self._update_sizes(changed)):
+            return
+
+        self.clear_layout()
+        self._rv_positions = None
+        if not data:
+            l, t, r, b = self.padding
+            self.minimum_size = l + r, t + b
+            return
+
+        view_opts = self.view_opts
+        n = len(view_opts)
+        for i, x, y, w, h in self._iterate_layout(
+                [(opt['size'], opt['size_hint'], opt['pos_hint'],
+                  opt['size_hint_min'], opt['size_hint_max']) for
+                 opt in reversed(view_opts)]):
+            opt = view_opts[n - i - 1]
+            shw, shh = opt['size_hint']
+            opt['pos'] = x, y
+            wo, ho = opt['size']
+            # layout won't/shouldn't change previous size if size_hint is None
+            # which is what w/h being None means.
+            opt['size'] = [(wo if shw is None else w),
+                           (ho if shh is None else h)]
+
+        spacing = self.spacing
+        pos = self._rv_positions = [None, ] * len(data)
+
+        if self.orientation == 'horizontal':
+            pos[0] = self.x
+            last = pos[0] + self.padding[0] + view_opts[0]['size'][0] + \
+                spacing / 2.
+            for i, val in enumerate(view_opts[1:], 1):
+                pos[i] = last
+                last += val['size'][0] + spacing
+        else:
+            last = pos[-1] = \
+                self.y + self.height - self.padding[1] - \
+                view_opts[0]['size'][1] - spacing / 2.
+            n = len(view_opts)
+            for i, val in enumerate(view_opts[1:], 1):
+                last -= spacing + val['size'][1]
+                pos[n - 1 - i] = last
+
+    def get_view_index_at(self, pos):
+        calc_pos = self._rv_positions
+        if not calc_pos:
+            return 0
+
+        x, y = pos
+
+        if self.orientation == 'horizontal':
+            if x >= calc_pos[-1] or len(calc_pos) == 1:
+                return len(calc_pos) - 1
+
+            ix = 0
+            for val in calc_pos[1:]:
+                if x < val:
+                    return ix
+                ix += 1
+        else:
+            if y >= calc_pos[-1] or len(calc_pos) == 1:
+                return 0
+
+            iy = 0
+            for val in calc_pos[1:]:
+                if y < val:
+                    return len(calc_pos) - iy - 1
+                iy += 1
+
+        assert False
+
+    def compute_visible_views(self, data, viewport):
+        if self._rv_positions is None or not data:
+            return []
+
+        x, y, w, h = viewport
+        at_idx = self.get_view_index_at
+        if self.orientation == 'horizontal':
+            a, b = at_idx((x, y)), at_idx((x + w, y))
+        else:
+            a, b = at_idx((x, y + h)), at_idx((x, y))
+        return list(range(a, b + 1))
diff --git a/kivy/uix/recyclegridlayout.py b/kivy/uix/recyclegridlayout.py
new file mode 100644
index 0000000..6fb4196
--- /dev/null
+++ b/kivy/uix/recyclegridlayout.py
@@ -0,0 +1,255 @@
+"""
+RecycleGridLayout
+=================
+
+.. versionadded:: 1.10.0
+
+.. warning::
+    This module is highly experimental, its API may change in the future and
+    the documentation is not complete at this time.
+
+The RecycleGridLayout is designed to provide a
+:class:`~kivy.uix.gridlayout.GridLayout` type layout when used with the
+:class:`~kivy.uix.recycleview.RecycleView` widget. Please refer to the
+:mod:`~kivy.uix.recycleview` module documentation for more information.
+"""
+
+import itertools
+chain_from_iterable = itertools.chain.from_iterable
+from kivy.uix.recyclelayout import RecycleLayout
+from kivy.uix.gridlayout import GridLayout, GridLayoutException, nmax, nmin
+from collections import defaultdict
+
+__all__ = ('RecycleGridLayout', )
+
+
+class RecycleGridLayout(RecycleLayout, GridLayout):
+
+    _cols_pos = None
+    _rows_pos = None
+
+    def __init__(self, **kwargs):
+        super(RecycleGridLayout, self).__init__(**kwargs)
+        self.funbind('children', self._trigger_layout)
+
+    def on_children(self, instance, value):
+        pass
+
+    def _fill_rows_cols_sizes(self):
+        cols, rows = self._cols, self._rows
+        cols_sh, rows_sh = self._cols_sh, self._rows_sh
+        cols_sh_min, rows_sh_min = self._cols_sh_min, self._rows_sh_min
+        cols_sh_max, rows_sh_max = self._cols_sh_max, self._rows_sh_max
+        self._cols_count = cols_count = [defaultdict(int) for _ in cols]
+        self._rows_count = rows_count = [defaultdict(int) for _ in rows]
+
+        # calculate minimum size for each columns and rows
+        idx_iter = self._create_idx_iter(len(cols), len(rows))
+        has_bound_y = has_bound_x = False
+        for opt, (col, row) in zip(self.view_opts, idx_iter):
+            (shw, shh), (w, h) = opt['size_hint'], opt['size']
+            shw_min, shh_min = opt['size_hint_min']
+            shw_max, shh_max = opt['size_hint_max']
+
+            if shw is None:
+                cols_count[col][w] += 1
+            if shh is None:
+                rows_count[row][h] += 1
+
+            # compute minimum size / maximum stretch needed
+            if shw is None:
+                cols[col] = nmax(cols[col], w)
+            else:
+                cols_sh[col] = nmax(cols_sh[col], shw)
+                if shw_min is not None:
+                    has_bound_x = True
+                    cols_sh_min[col] = nmax(cols_sh_min[col], shw_min)
+                if shw_max is not None:
+                    has_bound_x = True
+                    cols_sh_max[col] = nmin(cols_sh_max[col], shw_max)
+
+            if shh is None:
+                rows[row] = nmax(rows[row], h)
+            else:
+                rows_sh[row] = nmax(rows_sh[row], shh)
+                if shh_min is not None:
+                    has_bound_y = True
+                    rows_sh_min[row] = nmax(rows_sh_min[row], shh_min)
+                if shh_max is not None:
+                    has_bound_y = True
+                    rows_sh_max[row] = nmin(rows_sh_max[row], shh_max)
+        self._has_hint_bound_x = has_bound_x
+        self._has_hint_bound_y = has_bound_y
+
+    def _update_rows_cols_sizes(self, changed):
+        cols_count, rows_count = self._cols_count, self._rows_count
+        cols, rows = self._cols, self._rows
+        remove_view = self.remove_view
+        n_cols = len(cols)
+        n_rows = len(rows)
+        orientation = self.orientation
+
+        # this can be further improved to reduce re-comp, but whatever...
+        for index, widget, (w, h), (wn, hn), sh, shn, sh_min, shn_min, \
+                sh_max, shn_max, _, _ in changed:
+            if sh != shn or sh_min != shn_min or sh_max != shn_max:
+                return True
+            elif (sh[0] is not None and w != wn and
+                  (h == hn or sh[1] is not None) or
+                  sh[1] is not None and h != hn and
+                  (w == wn or sh[0] is not None)):
+                remove_view(widget, index)
+            else:  # size hint is None, so check if it can be resized inplace
+                col, row = self._calculate_idx_from_a_view_idx(
+                    n_cols, n_rows, index)
+                if w != wn:
+                    col_w = cols[col]
+                    cols_count[col][w] -= 1
+                    cols_count[col][wn] += 1
+                    was_last_w = cols_count[col][w] <= 0
+                    if was_last_w and col_w == w or wn > col_w:
+                        return True
+                    if was_last_w:
+                        del cols_count[col][w]
+
+                if h != hn:
+                    row_h = rows[row]
+                    rows_count[row][h] -= 1
+                    rows_count[row][hn] += 1
+                    was_last_h = rows_count[row][h] <= 0
+                    if was_last_h and row_h == h or hn > row_h:
+                        return True
+                    if was_last_h:
+                        del rows_count[row][h]
+
+        return False
+
+    def compute_layout(self, data, flags):
+        super(RecycleGridLayout, self).compute_layout(data, flags)
+
+        n = len(data)
+        smax = self.get_max_widgets()
+        if smax and n > smax:
+            raise GridLayoutException(
+                'Too many children ({}) in GridLayout. Increase rows/cols!'.
+                format(n))
+
+        changed = self._changed_views
+        if (changed is None or
+                changed and not self._update_rows_cols_sizes(changed)):
+            return
+
+        self.clear_layout()
+        if not self._init_rows_cols_sizes(n):
+            self._cols_pos = None
+            l, t, r, b = self.padding
+            self.minimum_size = l + r, t + b
+            return
+        self._fill_rows_cols_sizes()
+        self._update_minimum_size()
+        self._finalize_rows_cols_sizes()
+
+        view_opts = self.view_opts
+        for widget, x, y, w, h in self._iterate_layout(n):
+            opt = view_opts[n - widget - 1]
+            shw, shh = opt['size_hint']
+            opt['pos'] = x, y
+            wo, ho = opt['size']
+            # layout won't/shouldn't change previous size if size_hint is None
+            # which is what w/h being None means.
+            opt['size'] = [(wo if shw is None else w),
+                           (ho if shh is None else h)]
+
+        spacing_x, spacing_y = self.spacing
+        cols, rows = self._cols, self._rows
+
+        cols_pos = self._cols_pos = [None, ] * len(cols)
+        rows_pos = self._rows_pos = [None, ] * len(rows)
+
+        cols_pos[0] = self.x
+        last = cols_pos[0] + self.padding[0] + cols[0] + spacing_x / 2.
+        for i, val in enumerate(cols[1:], 1):
+            cols_pos[i] = last
+            last += val + spacing_x
+
+        last = rows_pos[-1] = \
+            self.y + self.height - self.padding[1] - rows[0] - spacing_y / 2.
+        n = len(rows)
+        for i, val in enumerate(rows[1:], 1):
+            last -= spacing_y + val
+            rows_pos[n - 1 - i] = last
+
+    def get_view_index_at(self, pos):
+        if self._cols_pos is None:
+            return 0
+
+        x, y = pos
+        col_pos = self._cols_pos
+        row_pos = self._rows_pos
+        cols, rows = self._cols, self._rows
+        if not col_pos or not row_pos:
+            return 0
+
+        if x >= col_pos[-1]:
+            ix = len(cols) - 1
+        else:
+            ix = 0
+            for val in col_pos[1:]:
+                if x < val:
+                    break
+                ix += 1
+
+        if y >= row_pos[-1]:
+            iy = len(rows) - 1
+        else:
+            iy = 0
+            for val in row_pos[1:]:
+                if y < val:
+                    break
+                iy += 1
+
+        if not self._fills_from_left_to_right:
+            ix = len(cols) - ix - 1
+        if self._fills_from_top_to_bottom:
+            iy = len(rows) - iy - 1
+        return (iy * len(cols) + ix) if self._fills_row_first else \
+            (ix * len(rows) + iy)
+
+    def compute_visible_views(self, data, viewport):
+        if self._cols_pos is None:
+            return []
+        x, y, w, h = viewport
+        right = x + w
+        top = y + h
+        at_idx = self.get_view_index_at
+        tl, tr, bl, br = sorted((
+            at_idx((x, y)),
+            at_idx((right, y)),
+            at_idx((x, top)),
+            at_idx((right, top)),
+        ))
+
+        n = len(data)
+        if len({tl, tr, bl, br}) < 4:
+            # visible area is one row/column
+            return range(min(n, tl), min(n, br + 1))
+        indices = []
+        stride = len(self._cols) if self._fills_row_first else len(self._rows)
+        if stride:
+            x_slice = br - bl + 1
+            indices = chain_from_iterable(
+                range(min(s, n), min(n, s + x_slice))
+                for s in range(tl, bl + 1, stride))
+        return indices
+
+    def _calculate_idx_from_a_view_idx(self, n_cols, n_rows, view_idx):
+        '''returns a tuple of (column-index, row-index) from a view-index'''
+        if self._fills_row_first:
+            row_idx, col_idx = divmod(view_idx, n_cols)
+        else:
+            col_idx, row_idx = divmod(view_idx, n_rows)
+        if not self._fills_from_left_to_right:
+            col_idx = n_cols - col_idx - 1
+        if not self._fills_from_top_to_bottom:
+            row_idx = n_rows - row_idx - 1
+        return (col_idx, row_idx, )
diff --git a/kivy/uix/recyclelayout.py b/kivy/uix/recyclelayout.py
new file mode 100644
index 0000000..90c3a50
--- /dev/null
+++ b/kivy/uix/recyclelayout.py
@@ -0,0 +1,446 @@
+"""
+RecycleLayout
+=============
+
+.. versionadded:: 1.10.0
+
+.. warning::
+    This module is highly experimental, its API may change in the future and
+    the documentation is not complete at this time.
+"""
+
+from kivy.uix.recycleview.layout import RecycleLayoutManagerBehavior
+from kivy.uix.layout import Layout
+from kivy.properties import (
+    ObjectProperty, StringProperty, ReferenceListProperty, NumericProperty
+)
+from kivy.factory import Factory
+
+__all__ = ('RecycleLayout', )
+
+
+class RecycleLayout(RecycleLayoutManagerBehavior, Layout):
+    """
+    RecycleLayout provides the default layout for RecycleViews.
+    """
+
+    default_width = NumericProperty(100, allownone=True)
+    '''Default width for items
+
+    :attr:`default_width` is a NumericProperty and default to 100
+    '''
+    default_height = NumericProperty(100, allownone=True)
+    '''Default height for items
+
+    :attr:`default_height` is a :class:`~kivy.properties.NumericProperty` and
+    default to 100.
+    '''
+    default_size = ReferenceListProperty(default_width, default_height)
+    '''size (width, height). Each value can be None.
+
+    :attr:`default_size` is an :class:`~kivy.properties.ReferenceListProperty`
+    to [:attr:`default_width`, :attr:`default_height`].
+    '''
+    default_size_hint_x = NumericProperty(None, allownone=True)
+    '''Default size_hint_x for items
+
+    :attr:`default_size_hint_x` is a :class:`~kivy.properties.NumericProperty`
+    and default to None.
+    '''
+    default_size_hint_y = NumericProperty(None, allownone=True)
+    '''Default size_hint_y for items
+
+    :attr:`default_size_hint_y` is a :class:`~kivy.properties.NumericProperty`
+    and default to None.
+    '''
+    default_size_hint = ReferenceListProperty(
+        default_size_hint_x, default_size_hint_y
+    )
+    '''size (width, height). Each value can be None.
+
+    :attr:`default_size_hint` is an
+    :class:`~kivy.properties.ReferenceListProperty` to
+    [:attr:`default_size_hint_x`, :attr:`default_size_hint_y`].
+    '''
+
+    key_size = StringProperty(None, allownone=True)
+    '''If set, which key in the dict should be used to set the size property of
+    the item.
+
+    :attr:`key_size` is a :class:`~kivy.properties.StringProperty` and defaults
+    to None.
+    '''
+    key_size_hint = StringProperty(None, allownone=True)
+    '''If set, which key in the dict should be used to set the size_hint
+    property of the item.
+
+    :attr:`key_size_hint` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    key_size_hint_min = StringProperty(None, allownone=True)
+    '''If set, which key in the dict should be used to set the size_hint_min
+    property of the item.
+
+    :attr:`key_size_hint_min` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+    default_size_hint_x_min = NumericProperty(None, allownone=True)
+    '''Default value for size_hint_x_min of items
+
+    :attr:`default_pos_hint_x_min` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to None.
+    '''
+    default_size_hint_y_min = NumericProperty(None, allownone=True)
+    '''Default value for size_hint_y_min of items
+
+    :attr:`default_pos_hint_y_min` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to None.
+    '''
+    default_size_hint_min = ReferenceListProperty(
+        default_size_hint_x_min,
+        default_size_hint_y_min
+    )
+    '''Default value for size_hint_min of items
+
+    :attr:`default_size_min` is a
+    :class:`~kivy.properties.ReferenceListProperty` to
+    [:attr:`default_size_hint_x_min`, :attr:`default_size_hint_y_min`].
+    '''
+
+    key_size_hint_max = StringProperty(None, allownone=True)
+    '''If set, which key in the dict should be used to set the size_hint_max
+    property of the item.
+
+    :attr:`key_size_hint_max` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+    default_size_hint_x_max = NumericProperty(None, allownone=True)
+    '''Default value for size_hint_x_max of items
+
+    :attr:`default_pos_hint_x_max` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to None.
+    '''
+    default_size_hint_y_max = NumericProperty(None, allownone=True)
+    '''Default value for size_hint_y_max of items
+
+    :attr:`default_pos_hint_y_max` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to None.
+    '''
+    default_size_hint_max = ReferenceListProperty(
+        default_size_hint_x_max,
+        default_size_hint_y_max
+    )
+    '''Default value for size_hint_max of items
+
+    :attr:`default_size_max` is a
+    :class:`~kivy.properties.ReferenceListProperty` to
+    [:attr:`default_size_hint_x_max`, :attr:`default_size_hint_y_max`].
+    '''
+
+    default_pos_hint = ObjectProperty({})
+    '''Default pos_hint value for items
+
+    :attr:`default_pos_hint` is a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+    '''
+    key_pos_hint = StringProperty(None, allownone=True)
+    '''If set, which key in the dict should be used to set the pos_hint of
+    items.
+
+    :attr:`key_pos_hint` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    initial_width = NumericProperty(100)
+    '''Initial width for the items.
+
+    :attr:`initial_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 100.
+    '''
+    initial_height = NumericProperty(100)
+    '''Initial height for the items.
+
+    :attr:`initial_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 100.
+    '''
+    initial_size = ReferenceListProperty(initial_width, initial_height)
+    '''Initial size of items
+
+    :attr:`initial_size` is a :class:`~kivy.properties.ReferenceListProperty`
+    to [:attr:`initial_width`, :attr:`initial_height`].
+    '''
+
+    view_opts = []
+
+    _size_needs_update = False
+    _changed_views = []
+
+    view_indices = {}
+
+    def __init__(self, **kwargs):
+        self.view_indices = {}
+        self._updated_views = []
+        self._trigger_layout = self._catch_layout_trigger
+        super(RecycleLayout, self).__init__(**kwargs)
+
+    def attach_recycleview(self, rv):
+        super(RecycleLayout, self).attach_recycleview(rv)
+        if rv:
+            fbind = self.fbind
+            fbind('default_size', rv.refresh_from_data)
+            fbind('key_size', rv.refresh_from_data)
+            fbind('default_size_hint', rv.refresh_from_data)
+            fbind('key_size_hint', rv.refresh_from_data)
+            fbind('default_size_hint_min', rv.refresh_from_data)
+            fbind('key_size_hint_min', rv.refresh_from_data)
+            fbind('default_size_hint_max', rv.refresh_from_data)
+            fbind('key_size_hint_max', rv.refresh_from_data)
+            fbind('default_pos_hint', rv.refresh_from_data)
+            fbind('key_pos_hint', rv.refresh_from_data)
+
+    def detach_recycleview(self):
+        rv = self.recycleview
+        if rv:
+            funbind = self.funbind
+            funbind('default_size', rv.refresh_from_data)
+            funbind('key_size', rv.refresh_from_data)
+            funbind('default_size_hint', rv.refresh_from_data)
+            funbind('key_size_hint', rv.refresh_from_data)
+            funbind('default_size_hint_min', rv.refresh_from_data)
+            funbind('key_size_hint_min', rv.refresh_from_data)
+            funbind('default_size_hint_max', rv.refresh_from_data)
+            funbind('key_size_hint_max', rv.refresh_from_data)
+            funbind('default_pos_hint', rv.refresh_from_data)
+            funbind('key_pos_hint', rv.refresh_from_data)
+        super(RecycleLayout, self).detach_recycleview()
+
+    def _catch_layout_trigger(self, instance=None, value=None):
+        rv = self.recycleview
+        if rv is None:
+            return
+
+        idx = self.view_indices.get(instance)
+        if idx is not None:
+            if self._size_needs_update:
+                return
+            opt = self.view_opts[idx]
+            if (instance.size == opt['size'] and
+                    instance.size_hint == opt['size_hint'] and
+                    instance.size_hint_min == opt['size_hint_min'] and
+                    instance.size_hint_max == opt['size_hint_max'] and
+                    instance.pos_hint == opt['pos_hint']):
+                return
+            self._size_needs_update = True
+            rv.refresh_from_layout(view_size=True)
+        else:
+            rv.refresh_from_layout()
+
+    def compute_sizes_from_data(self, data, flags):
+        if [f for f in flags if not f]:
+            # at least one changed data unpredictably
+            self.clear_layout()
+            opts = self.view_opts = [None for _ in data]
+        else:
+            opts = self.view_opts
+            changed = False
+            for flag in flags:
+                for k, v in flag.items():
+                    changed = True
+                    if k == 'removed':
+                        del opts[v]
+                    elif k == 'appended':
+                        opts.extend([None, ] * (v.stop - v.start))
+                    elif k == 'inserted':
+                        opts.insert(v, None)
+                    elif k == 'modified':
+                        start, stop, step = v.start, v.stop, v.step
+                        r = range(start, stop) if step is None else \
+                            range(start, stop, step)
+                        for i in r:
+                            opts[i] = None
+                    else:
+                        raise Exception('Unrecognized data flag {}'.format(k))
+
+            if changed:
+                self.clear_layout()
+
+        assert len(data) == len(opts)
+        ph_key = self.key_pos_hint
+        ph_def = self.default_pos_hint
+        sh_key = self.key_size_hint
+        sh_def = self.default_size_hint
+        sh_min_key = self.key_size_hint_min
+        sh_min_def = self.default_size_hint_min
+        sh_max_key = self.key_size_hint_max
+        sh_max_def = self.default_size_hint_max
+        s_key = self.key_size
+        s_def = self.default_size
+        viewcls_def = self.viewclass
+        viewcls_key = self.key_viewclass
+        iw, ih = self.initial_size
+
+        sh = []
+        for i, item in enumerate(data):
+            if opts[i] is not None:
+                continue
+
+            ph = ph_def if ph_key is None else item.get(ph_key, ph_def)
+            ph = item.get('pos_hint', ph)
+
+            sh = sh_def if sh_key is None else item.get(sh_key, sh_def)
+            sh = item.get('size_hint', sh)
+            sh = [item.get('size_hint_x', sh[0]),
+                  item.get('size_hint_y', sh[1])]
+
+            sh_min = sh_min_def if sh_min_key is None else item.get(sh_min_key,
+                                                                    sh_min_def)
+            sh_min = item.get('size_hint_min', sh_min)
+            sh_min = [item.get('size_hint_min_x', sh_min[0]),
+                      item.get('size_hint_min_y', sh_min[1])]
+
+            sh_max = sh_max_def if sh_max_key is None else item.get(sh_max_key,
+                                                                    sh_max_def)
+            sh_max = item.get('size_hint_max', sh_max)
+            sh_max = [item.get('size_hint_max_x', sh_max[0]),
+                      item.get('size_hint_max_y', sh_max[1])]
+
+            s = s_def if s_key is None else item.get(s_key, s_def)
+            s = item.get('size', s)
+            w, h = s = item.get('width', s[0]), item.get('height', s[1])
+
+            viewcls = None
+            if viewcls_key is not None:
+                viewcls = item.get(viewcls_key)
+                if viewcls is not None:
+                    viewcls = getattr(Factory, viewcls)
+            if viewcls is None:
+                viewcls = viewcls_def
+
+            opts[i] = {
+                'size': [(iw if w is None else w), (ih if h is None else h)],
+                'size_hint': sh, 'size_hint_min': sh_min,
+                'size_hint_max': sh_max, 'pos': None, 'pos_hint': ph,
+                'viewclass': viewcls, 'width_none': w is None,
+                'height_none': h is None}
+
+    def compute_layout(self, data, flags):
+        self._size_needs_update = False
+
+        opts = self.view_opts
+        changed = []
+        for widget, index in self.view_indices.items():
+            opt = opts[index]
+            s = opt['size']
+            w, h = sn = list(widget.size)
+            sh = opt['size_hint']
+            shnw, shnh = shn = list(widget.size_hint)
+            sh_min = opt['size_hint_min']
+            shn_min = list(widget.size_hint_min)
+            sh_max = opt['size_hint_max']
+            shn_max = list(widget.size_hint_max)
+            ph = opt['pos_hint']
+            phn = dict(widget.pos_hint)
+            if s != sn or sh != shn or ph != phn or sh_min != shn_min or \
+                    sh_max != shn_max:
+                changed.append((index, widget, s, sn, sh, shn, sh_min, shn_min,
+                                sh_max, shn_max, ph, phn))
+                if shnw is None:
+                    if shnh is None:
+                        opt['size'] = sn
+                    else:
+                        opt['size'] = [w, s[1]]
+                elif shnh is None:
+                    opt['size'] = [s[0], h]
+                opt['size_hint'] = shn
+                opt['size_hint_min'] = shn_min
+                opt['size_hint_max'] = shn_max
+                opt['pos_hint'] = phn
+
+        if [f for f in flags if not f]:  # need to redo everything
+            self._changed_views = []
+        else:
+            self._changed_views = changed if changed else None
+
+    def do_layout(self, *largs):
+        assert False
+
+    def set_visible_views(self, indices, data, viewport):
+        view_opts = self.view_opts
+        new, remaining, old = self.recycleview.view_adapter.set_visible_views(
+            indices, data, view_opts)
+
+        remove = self.remove_widget
+        view_indices = self.view_indices
+        for _, widget in old:
+            remove(widget)
+            del view_indices[widget]
+
+        # first update the sizing info so that when we update the size
+        # the widgets are not bound and won't trigger a re-layout
+        refresh_view_layout = self.refresh_view_layout
+        for index, widget in new:
+            # make sure widget is added first so that any sizing updates
+            # will be recorded
+            opt = view_opts[index].copy()
+            del opt['width_none']
+            del opt['height_none']
+            refresh_view_layout(index, opt, widget, viewport)
+
+        # then add all the visible widgets, which binds size/size_hint
+        add = self.add_widget
+        for index, widget in new:
+            # add to the container if it's not already done
+            view_indices[widget] = index
+            if widget.parent is None:
+                add(widget)
+
+        # finally, make sure if the size has changed to cause a re-layout
+        changed = False
+        for index, widget in new:
+            opt = view_opts[index]
+            if (changed or widget.size == opt['size'] and
+                    widget.size_hint == opt['size_hint'] and
+                    widget.size_hint_min == opt['size_hint_min'] and
+                    widget.size_hint_max == opt['size_hint_max'] and
+                    widget.pos_hint == opt['pos_hint']):
+                continue
+            changed = True
+
+        if changed:
+            # we could use LayoutChangeException here, but refresh_views in rv
+            # needs to be updated to watch for it in the layout phase
+            self._size_needs_update = True
+            self.recycleview.refresh_from_layout(view_size=True)
+
+    def refresh_view_layout(self, index, layout, view, viewport):
+        opt = self.view_opts[index].copy()
+        width_none = opt.pop('width_none')
+        height_none = opt.pop('height_none')
+        opt.update(layout)
+
+        w, h = opt['size']
+        shw, shh = opt['size_hint']
+        if shw is None and width_none:
+            w = None
+        if shh is None and height_none:
+            h = None
+        opt['size'] = w, h
+        super(RecycleLayout, self).refresh_view_layout(
+            index, opt, view, viewport)
+
+    def remove_views(self):
+        super(RecycleLayout, self).remove_views()
+        self.clear_widgets()
+        self.view_indices = {}
+
+    def remove_view(self, view, index):
+        super(RecycleLayout, self).remove_view(view, index)
+        self.remove_widget(view)
+        del self.view_indices[view]
+
+    def clear_layout(self):
+        super(RecycleLayout, self).clear_layout()
+        self.clear_widgets()
+        self.view_indices = {}
+        self._size_needs_update = False
diff --git a/kivy/uix/recycleview/__init__.py b/kivy/uix/recycleview/__init__.py
new file mode 100644
index 0000000..b1cf030
--- /dev/null
+++ b/kivy/uix/recycleview/__init__.py
@@ -0,0 +1,624 @@
+"""
+RecycleView
+===========
+
+.. versionadded:: 1.10.0
+
+The RecycleView provides a flexible model for viewing selected sections of
+large data sets. It aims to prevent the performance degradation that can occur
+when generating large numbers of widgets in order to display many data items.
+
+.. warning::
+
+    Because :class:`RecycleView` reuses widgets, any state change to a single
+    widget will stay with that widget as it's reused, even if the
+    :attr:`~RecycleView.data` assigned to it by the :class:`RecycleView`
+    changes. Unless the complete state is tracked in :attr:`~RecycleView.data`
+    (see below).
+
+The view is generatad by processing the :attr:`~RecycleView.data`, essentially
+a list of dicts, and uses these dicts to generate instances of the
+:attr:`~RecycleView.viewclass` as required. Its design is based on the
+MVC (`Model-view-controller
+<https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller>`_)
+pattern.
+
+* Model: The model is formed by :attr:`~RecycleView.data` you pass in via a
+  list of dicts.
+* View: The View is split across layout and views and implemented using
+  adapters.
+* Controller: The controller determines the logical interaction and is
+  implemented by :class:`RecycleViewBehavior`.
+
+These are abstract classes and cannot be used directly. The default concrete
+implementations are the
+:class:`~kivy.uix.recycleview.datamodel.RecycleDataModel` for the model, the
+:class:`~kivy.uix.recyclelayout.RecycleLayout` for the view, and the
+:class:`RecycleView` for the controller.
+
+When a RecycleView is instantiated, it automatically creates the views and data
+classes. However, one must manually create the layout classes and add them to
+the RecycleView.
+
+A layout manager is automatically created as a
+:attr:`~RecycleViewBehavior.layout_manager` when added as the child of the
+RecycleView. Similarly when removed. A requirement is that the layout manager
+must be contained as a child somewhere within the RecycleView's widget tree so
+the view port can be found.
+
+A minimal example might look something like this::
+
+    from kivy.app import App
+    from kivy.lang import Builder
+    from kivy.uix.recycleview import RecycleView
+
+
+    Builder.load_string('''
+    <RV>:
+        viewclass: 'Label'
+        RecycleBoxLayout:
+            default_size: None, dp(56)
+            default_size_hint: 1, None
+            size_hint_y: None
+            height: self.minimum_height
+            orientation: 'vertical'
+    ''')
+
+    class RV(RecycleView):
+        def __init__(self, **kwargs):
+            super(RV, self).__init__(**kwargs)
+            self.data = [{'text': str(x)} for x in range(100)]
+
+
+    class TestApp(App):
+        def build(self):
+            return RV()
+
+    if __name__ == '__main__':
+        TestApp().run()
+
+In order to support selection in the view, you can add the required behaviours
+as follows::
+
+    from kivy.app import App
+    from kivy.lang import Builder
+    from kivy.uix.recycleview import RecycleView
+    from kivy.uix.recycleview.views import RecycleDataViewBehavior
+    from kivy.uix.label import Label
+    from kivy.properties import BooleanProperty
+    from kivy.uix.recycleboxlayout import RecycleBoxLayout
+    from kivy.uix.behaviors import FocusBehavior
+    from kivy.uix.recycleview.layout import LayoutSelectionBehavior
+
+    Builder.load_string('''
+    <SelectableLabel>:
+        # Draw a background to indicate selection
+        canvas.before:
+            Color:
+                rgba: (.0, 0.9, .1, .3) if self.selected else (0, 0, 0, 1)
+            Rectangle:
+                pos: self.pos
+                size: self.size
+    <RV>:
+        viewclass: 'SelectableLabel'
+        SelectableRecycleBoxLayout:
+            default_size: None, dp(56)
+            default_size_hint: 1, None
+            size_hint_y: None
+            height: self.minimum_height
+            orientation: 'vertical'
+            multiselect: True
+            touch_multiselect: True
+    ''')
+
+
+    class SelectableRecycleBoxLayout(FocusBehavior, LayoutSelectionBehavior,
+                                     RecycleBoxLayout):
+        ''' Adds selection and focus behaviour to the view. '''
+
+
+    class SelectableLabel(RecycleDataViewBehavior, Label):
+        ''' Add selection support to the Label '''
+        index = None
+        selected = BooleanProperty(False)
+        selectable = BooleanProperty(True)
+
+        def refresh_view_attrs(self, rv, index, data):
+            ''' Catch and handle the view changes '''
+            self.index = index
+            return super(SelectableLabel, self).refresh_view_attrs(
+                rv, index, data)
+
+        def on_touch_down(self, touch):
+            ''' Add selection on touch down '''
+            if super(SelectableLabel, self).on_touch_down(touch):
+                return True
+            if self.collide_point(*touch.pos) and self.selectable:
+                return self.parent.select_with_touch(self.index, touch)
+
+        def apply_selection(self, rv, index, is_selected):
+            ''' Respond to the selection of items in the view. '''
+            self.selected = is_selected
+            if is_selected:
+                print("selection changed to {0}".format(rv.data[index]))
+            else:
+                print("selection removed for {0}".format(rv.data[index]))
+
+
+    class RV(RecycleView):
+        def __init__(self, **kwargs):
+            super(RV, self).__init__(**kwargs)
+            self.data = [{'text': str(x)} for x in range(100)]
+
+
+    class TestApp(App):
+        def build(self):
+            return RV()
+
+    if __name__ == '__main__':
+        TestApp().run()
+
+
+
+Please see the `examples/widgets/recycleview/basic_data.py` file for a more
+complete example.
+
+Viewclass State
+^^^^^^^^^^^^^^^
+
+Because the viewclass widgets are reused or instantiated as needed by the
+:class:`RecycleView`, the order and content of the widgets are mutable. So any
+state change to a single widget will stay with that widget, even when the data
+assigned to it from the :attr:`~RecycleView.data` dict changes, unless
+:attr:`~RecycleView.data` tracks those changes or they are manually refreshed
+when re-used.
+
+There are two methods for managing state changes in viewclass widgets:
+
+1. Store state in the RecycleView.data Model
+2. Generate state changes on-the-fly by catching :attr:`~RecycleView.data`
+   updates and manually refreshing.
+
+An example::
+
+    from kivy.app import App
+    from kivy.lang import Builder
+    from kivy.uix.boxlayout import BoxLayout
+    from kivy.uix.recycleview import RecycleView
+    from kivy.uix.recycleview.views import RecycleDataViewBehavior
+    from kivy.properties import BooleanProperty, StringProperty
+
+    Builder.load_string('''
+    <StatefulLabel>:
+        active: stored_state.active
+        CheckBox:
+            id: stored_state
+            active: root.active
+            on_release: root.store_checkbox_state()
+        Label:
+            text: root.text
+        Label:
+            id: generate_state
+            text: root.generated_state_text
+
+    <RV>:
+        viewclass: 'StatefulLabel'
+        RecycleBoxLayout:
+            size_hint_y: None
+            height: self.minimum_height
+            orientation: 'vertical'
+    ''')
+
+    class StatefulLabel(RecycleDataViewBehavior, BoxLayout):
+        text = StringProperty()
+        generated_state_text = StringProperty()
+        active = BooleanProperty()
+        index = 0
+
+        '''
+        To change a viewclass' state as the data assigned to it changes,
+        overload the refresh_view_attrs function (inherited from
+        RecycleDataViewBehavior)
+        '''
+        def refresh_view_attrs(self, rv, index, data):
+            self.index = index
+            if data['text'] == '0':
+                self.generated_state_text = "is zero"
+            elif int(data['text']) % 2 == 1:
+                self.generated_state_text = "is odd"
+            else:
+                self.generated_state_text = "is even"
+            super(StatefulLabel, self).refresh_view_attrs(rv, index, data)
+
+        '''
+        To keep state changes in the viewclass with associated data,
+        they can be explicitly stored in the RecycleView's data object
+        '''
+        def store_checkbox_state(self):
+            rv = App.get_running_app().rv
+            rv.data[self.index]['active'] = self.active
+
+    class RV(RecycleView, App):
+        def __init__(self, **kwargs):
+            super(RV, self).__init__(**kwargs)
+            self.data = [{'text': str(x), 'active': False} for x in range(10)]
+            App.get_running_app().rv = self
+
+        def build(self):
+            return self
+
+    if __name__ == '__main__':
+        RV().run()
+
+TODO:
+    - Method to clear cached class instances.
+    - Test when views cannot be found (e.g. viewclass is None).
+    - Fix selection goto.
+
+.. warning::
+    When views are re-used they may not trigger if the data remains the same.
+"""
+
+__all__ = ('RecycleViewBehavior', 'RecycleView')
+
+from copy import deepcopy
+
+from kivy.uix.scrollview import ScrollView
+from kivy.properties import AliasProperty
+from kivy.clock import Clock
+
+from kivy.uix.recycleview.layout import RecycleLayoutManagerBehavior, \
+    LayoutChangeException
+from kivy.uix.recycleview.views import RecycleDataAdapter
+from kivy.uix.recycleview.datamodel import RecycleDataModelBehavior, \
+    RecycleDataModel
+
+
+class RecycleViewBehavior(object):
+    """RecycleViewBehavior provides a behavioral model upon which the
+    :class:`RecycleView` is built. Together, they offer an extensible and
+    flexible way to produce views with limited windows over large data sets.
+
+    See the module documentation for more information.
+    """
+
+    # internals
+    _view_adapter = None
+    _data_model = None
+    _layout_manager = None
+
+    _refresh_flags = {'data': [], 'layout': [], 'viewport': False}
+    _refresh_trigger = None
+
+    def __init__(self, **kwargs):
+        self._refresh_trigger = Clock.create_trigger(self.refresh_views, -1)
+        self._refresh_flags = deepcopy(self._refresh_flags)
+        super(RecycleViewBehavior, self).__init__(**kwargs)
+
+    def get_viewport(self):
+        pass
+
+    def save_viewport(self):
+        pass
+
+    def restore_viewport(self):
+        pass
+
+    def refresh_views(self, *largs):
+        lm = self.layout_manager
+        flags = self._refresh_flags
+        if lm is None or self.view_adapter is None or self.data_model is None:
+            return
+
+        data = self.data
+        f = flags['data']
+        if f:
+            self.save_viewport()
+            # lm.clear_layout()
+            flags['data'] = []
+            flags['layout'] = [{}]
+            lm.compute_sizes_from_data(data, f)
+
+        while flags['layout']:
+            # if `data` we were re-triggered so finish in the next call.
+            # Otherwise go until fully laid out.
+            self.save_viewport()
+            if flags['data']:
+                return
+            flags['viewport'] = True
+            f = flags['layout']
+            flags['layout'] = []
+
+            try:
+                lm.compute_layout(data, f)
+            except LayoutChangeException:
+                flags['layout'].append({})
+                continue
+
+        if flags['data']:  # in case that happened meanwhile
+            return
+
+        # make sure if we were re-triggered in the loop that we won't be
+        # called needlessly later.
+        self._refresh_trigger.cancel()
+
+        self.restore_viewport()
+
+        if flags['viewport']:
+            # TODO: make this also listen to LayoutChangeException
+            flags['viewport'] = False
+            viewport = self.get_viewport()
+            indices = lm.compute_visible_views(data, viewport)
+            lm.set_visible_views(indices, data, viewport)
+
+    def refresh_from_data(self, *largs, **kwargs):
+        """
+        This should be called when data changes. Data changes typically
+        indicate that everything should be recomputed since the source data
+        changed.
+
+        This method is automatically bound to the
+        :attr:`~RecycleDataModelBehavior.on_data_changed` method of the
+        :class:`~RecycleDataModelBehavior` class and
+        therefore responds to and accepts the keyword arguments of that event.
+
+        It can be called manually to trigger an update.
+        """
+        self._refresh_flags['data'].append(kwargs)
+        self._refresh_trigger()
+
+    def refresh_from_layout(self, *largs, **kwargs):
+        """
+        This should be called when the layout changes or needs to change. It is
+        typically called when a layout parameter has changed and therefore the
+        layout needs to be recomputed.
+        """
+        self._refresh_flags['layout'].append(kwargs)
+        self._refresh_trigger()
+
+    def refresh_from_viewport(self, *largs):
+        """
+        This should be called when the viewport changes and the displayed data
+        must be updated. Neither the data nor the layout will be recomputed.
+        """
+        self._refresh_flags['viewport'] = True
+        self._refresh_trigger()
+
+    def _dispatch_prop_on_source(self, prop_name, *largs):
+        # Dispatches the prop of this class when the
+        # view_adapter/layout_manager property changes.
+        getattr(self.__class__, prop_name).dispatch(self)
+
+    def _get_data_model(self):
+        return self._data_model
+
+    def _set_data_model(self, value):
+        data_model = self._data_model
+        if value is data_model:
+            return
+        if data_model is not None:
+            self._data_model = None
+            data_model.detach_recycleview()
+
+        if value is None:
+            return True
+
+        if not isinstance(value, RecycleDataModelBehavior):
+            raise ValueError(
+                'Expected object based on RecycleDataModelBehavior, got {}'.
+                format(value.__class__))
+
+        self._data_model = value
+        value.attach_recycleview(self)
+        self.refresh_from_data()
+        return True
+
+    data_model = AliasProperty(_get_data_model, _set_data_model)
+    """
+    The Data model responsible for maintaining the data set.
+
+    data_model is an :class:`~kivy.properties.AliasProperty` that gets and sets
+    the current data model.
+    """
+
+    def _get_view_adapter(self):
+        return self._view_adapter
+
+    def _set_view_adapter(self, value):
+        view_adapter = self._view_adapter
+        if value is view_adapter:
+            return
+        if view_adapter is not None:
+            self._view_adapter = None
+            view_adapter.detach_recycleview()
+
+        if value is None:
+            return True
+
+        if not isinstance(value, RecycleDataAdapter):
+            raise ValueError(
+                'Expected object based on RecycleAdapter, got {}'.
+                format(value.__class__))
+
+        self._view_adapter = value
+        value.attach_recycleview(self)
+        self.refresh_from_layout()
+        return True
+
+    view_adapter = AliasProperty(_get_view_adapter, _set_view_adapter)
+    """
+    The adapter responsible for providing views that represent items in a data
+    set.
+
+    view_adapter is an :class:`~kivy.properties.AliasProperty` that gets and
+    sets the current view adapter.
+    """
+
+    def _get_layout_manager(self):
+        return self._layout_manager
+
+    def _set_layout_manager(self, value):
+        lm = self._layout_manager
+        if value is lm:
+            return
+
+        if lm is not None:
+            self._layout_manager = None
+            lm.detach_recycleview()
+
+        if value is None:
+            return True
+
+        if not isinstance(value, RecycleLayoutManagerBehavior):
+            raise ValueError(
+                'Expected object based on RecycleLayoutManagerBehavior, '
+                'got {}'.format(value.__class__))
+
+        self._layout_manager = value
+        value.attach_recycleview(self)
+        self.refresh_from_layout()
+        return True
+
+    layout_manager = AliasProperty(_get_layout_manager, _set_layout_manager)
+    """
+    The Layout manager responsible for positioning views within the
+    :class:`RecycleView`.
+
+    layout_manager is an :class:`~kivy.properties.AliasProperty` that gets
+    and sets the layout_manger.
+    """
+
+
+class RecycleView(RecycleViewBehavior, ScrollView):
+    """
+    RecycleView is a flexible view for providing a limited window
+    into a large data set.
+
+    See the module documentation for more information.
+    """
+    def __init__(self, **kwargs):
+        if self.data_model is None:
+            kwargs.setdefault('data_model', RecycleDataModel())
+        if self.view_adapter is None:
+            kwargs.setdefault('view_adapter', RecycleDataAdapter())
+        super(RecycleView, self).__init__(**kwargs)
+
+        fbind = self.fbind
+        fbind('scroll_x', self.refresh_from_viewport)
+        fbind('scroll_y', self.refresh_from_viewport)
+        fbind('size', self.refresh_from_viewport)
+        self.refresh_from_data()
+
+    def _convert_sv_to_lm(self, x, y):
+        lm = self.layout_manager
+        tree = [lm]
+        parent = lm.parent
+        while parent is not None and parent is not self:
+            tree.append(parent)
+            parent = parent.parent
+
+        if parent is not self:
+            raise Exception(
+                'The layout manager must be a sub child of the recycleview. '
+                'Could not find {} in the parent tree of {}'.format(self, lm))
+
+        for widget in reversed(tree):
+            x, y = widget.to_local(x, y)
+
+        return x, y
+
+    def get_viewport(self):
+        lm = self.layout_manager
+        lm_w, lm_h = lm.size
+        w, h = self.size
+        scroll_y = min(1, max(self.scroll_y, 0))
+        scroll_x = min(1, max(self.scroll_x, 0))
+
+        if lm_h <= h:
+            bottom = 0
+        else:
+            above = (lm_h - h) * scroll_y
+            bottom = max(0, lm_h - above - h)
+
+        bottom = max(0, (lm_h - h) * scroll_y)
+        left = max(0, (lm_w - w) * scroll_x)
+        width = min(w, lm_w)
+        height = min(h, lm_h)
+
+        # now convert the sv coordinates into the coordinates of the lm. In
+        # case there's a relative layout type widget in the parent tree
+        # between the sv and the lm.
+        left, bottom = self._convert_sv_to_lm(left, bottom)
+        return left, bottom, width, height
+
+    def save_viewport(self):
+        pass
+
+    def restore_viewport(self):
+        pass
+
+    def add_widget(self, widget, *args, **kwargs):
+        super(RecycleView, self).add_widget(widget, *args, **kwargs)
+        if (isinstance(widget, RecycleLayoutManagerBehavior) and
+                not self.layout_manager):
+            self.layout_manager = widget
+
+    def remove_widget(self, widget, *args, **kwargs):
+        super(RecycleView, self).remove_widget(widget, *args, **kwargs)
+        if self.layout_manager == widget:
+            self.layout_manager = None
+
+    # or easier way to use
+    def _get_data(self):
+        d = self.data_model
+        return d and d.data
+
+    def _set_data(self, value):
+        d = self.data_model
+        if d is not None:
+            d.data = value
+
+    data = AliasProperty(_get_data, _set_data, bind=["data_model"])
+    """
+    The data used by the current view adapter. This is a list of dicts whose
+    keys map to the corresponding property names of the
+    :attr:`~RecycleView.viewclass`.
+
+    data is an :class:`~kivy.properties.AliasProperty` that gets and sets the
+    data used to generate the views.
+    """
+
+    def _get_viewclass(self):
+        a = self.layout_manager
+        return a and a.viewclass
+
+    def _set_viewclass(self, value):
+        a = self.layout_manager
+        if a:
+            a.viewclass = value
+
+    viewclass = AliasProperty(_get_viewclass, _set_viewclass,
+                              bind=["layout_manager"])
+    """
+    The viewclass used by the current layout_manager.
+
+    viewclass is an :class:`~kivy.properties.AliasProperty` that gets and sets
+    the class used to generate the individual items presented in the view.
+    """
+
+    def _get_key_viewclass(self):
+        a = self.layout_manager
+        return a and a.key_viewclass
+
+    def _set_key_viewclass(self, value):
+        a = self.layout_manager
+        if a:
+            a.key_viewclass = value
+
+    key_viewclass = AliasProperty(_get_key_viewclass, _set_key_viewclass,
+                                  bind=["layout_manager"])
+    """
+    key_viewclass is an :class:`~kivy.properties.AliasProperty` that gets and
+    sets the key viewclass for the current
+    :attr:`~kivy.uix.recycleview.layout_manager`.
+    """
diff --git a/kivy/uix/recycleview/__pycache__/__init__.cpython-310.pyc b/kivy/uix/recycleview/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..6bdf205
Binary files /dev/null and b/kivy/uix/recycleview/__pycache__/__init__.cpython-310.pyc differ
diff --git a/kivy/uix/recycleview/__pycache__/datamodel.cpython-310.pyc b/kivy/uix/recycleview/__pycache__/datamodel.cpython-310.pyc
new file mode 100644
index 0000000..685e7c7
Binary files /dev/null and b/kivy/uix/recycleview/__pycache__/datamodel.cpython-310.pyc differ
diff --git a/kivy/uix/recycleview/__pycache__/layout.cpython-310.pyc b/kivy/uix/recycleview/__pycache__/layout.cpython-310.pyc
new file mode 100644
index 0000000..1f211f9
Binary files /dev/null and b/kivy/uix/recycleview/__pycache__/layout.cpython-310.pyc differ
diff --git a/kivy/uix/recycleview/__pycache__/views.cpython-310.pyc b/kivy/uix/recycleview/__pycache__/views.cpython-310.pyc
new file mode 100644
index 0000000..9a3f0b0
Binary files /dev/null and b/kivy/uix/recycleview/__pycache__/views.cpython-310.pyc differ
diff --git a/kivy/uix/recycleview/datamodel.py b/kivy/uix/recycleview/datamodel.py
new file mode 100644
index 0000000..88ad617
--- /dev/null
+++ b/kivy/uix/recycleview/datamodel.py
@@ -0,0 +1,194 @@
+'''
+RecycleView Data Model
+======================
+
+.. versionadded:: 1.10.0
+
+The data model part of the RecycleView model-view-controller pattern.
+
+It defines the models (classes) that store the data associated with a
+:class:`~kivy.uix.recycleview.RecycleViewBehavior`. Each model (class)
+determines how the data is stored and emits requests to the controller
+(:class:`~kivy.uix.recycleview.RecycleViewBehavior`) when the data is
+modified.
+'''
+
+from kivy.properties import ListProperty, ObservableDict, ObjectProperty
+from kivy.event import EventDispatcher
+from functools import partial
+
+__all__ = ('RecycleDataModelBehavior', 'RecycleDataModel')
+
+
+def recondition_slice_assign(val, last_len, new_len):
+    if not isinstance(val, slice):
+        return slice(val, val + 1)
+
+    diff = new_len - last_len
+
+    start, stop, step = val.start, val.stop, val.step
+    if stop <= start:
+        return slice(0, 0)
+
+    if step is not None and step != 1:
+        assert last_len == new_len
+        if stop < 0:
+            stop = max(0, last_len + stop)
+        stop = min(last_len, stop)
+
+        if start < 0:
+            start = max(0, last_len + start)
+        start = min(last_len, start)
+
+        return slice(start, stop, step)
+
+    if start < 0:
+        start = last_len + start
+    if stop < 0:
+        stop = last_len + stop
+
+    # whatever, too complicated don't try to compute it
+    if (start < 0 or stop < 0 or start > last_len or stop > last_len or
+            new_len != last_len):
+        return None
+
+    return slice(start, stop)
+
+
+class RecycleDataModelBehavior(object):
+    """:class:`RecycleDataModelBehavior` is the base class for the models
+    that describes and provides the data for the
+    :class:`~kivy.uix.recycleview.RecycleViewBehavior`.
+
+    :Events:
+        `on_data_changed`:
+            Fired when the data changes. The event may dispatch
+            keyword arguments specific to each implementation of the data
+            model.
+            When dispatched, the event and keyword arguments are forwarded to
+            :meth:`~kivy.uix.recycleview.RecycleViewBehavior.\
+refresh_from_data`.
+    """
+
+    __events__ = ("on_data_changed", )
+
+    recycleview = ObjectProperty(None, allownone=True)
+    '''The
+    :class:`~kivy.uix.recycleview.RecycleViewBehavior` instance
+    associated with this data model.
+    '''
+
+    def attach_recycleview(self, rv):
+        '''Associates a
+        :class:`~kivy.uix.recycleview.RecycleViewBehavior` with
+        this data model.
+        '''
+        self.recycleview = rv
+        if rv:
+            self.fbind('on_data_changed', rv.refresh_from_data)
+
+    def detach_recycleview(self):
+        '''Removes the
+        :class:`~kivy.uix.recycleview.RecycleViewBehavior`
+        associated with this data model.
+        '''
+        rv = self.recycleview
+        if rv:
+            self.funbind('on_data_changed', rv.refresh_from_data)
+        self.recycleview = None
+
+    def on_data_changed(self, *largs, **kwargs):
+        pass
+
+
+class RecycleDataModel(RecycleDataModelBehavior, EventDispatcher):
+    '''An implementation of :class:`RecycleDataModelBehavior` that keeps the
+    data in a indexable list. See :attr:`data`.
+
+    When data changes this class currently dispatches `on_data_changed`  with
+    one of the following additional keyword arguments.
+
+    `none`: no keyword argument
+        With no additional argument it means a generic data change.
+    `removed`: a slice or integer
+        The value is a slice or integer indicating the indices removed.
+    `appended`: a slice
+        The slice in :attr:`data` indicating the first and last new items
+        (i.e. the slice pointing to the new items added at the end).
+    `inserted`: a integer
+        The index in :attr:`data` where a new data item was inserted.
+    `modified`: a slice
+        The slice with the indices where the data has been modified.
+        This currently does not allow changing of size etc.
+    '''
+
+    data = ListProperty([])
+    '''Stores the model's data using a list.
+
+    The data for a item at index `i` can also be accessed with
+    :class:`RecycleDataModel` `[i]`.
+    '''
+
+    _last_len = 0
+
+    def __init__(self, **kwargs):
+        self.fbind('data', self._on_data_callback)
+        super(RecycleDataModel, self).__init__(**kwargs)
+
+    def __getitem__(self, index):
+        return self.data[index]
+
+    @property
+    def observable_dict(self):
+        '''A dictionary instance, which when modified will trigger a `data` and
+        consequently an `on_data_changed` dispatch.
+        '''
+        return partial(ObservableDict, self.__class__.data, self)
+
+    def attach_recycleview(self, rv):
+        super(RecycleDataModel, self).attach_recycleview(rv)
+        if rv:
+            self.fbind('data', rv._dispatch_prop_on_source, 'data')
+
+    def detach_recycleview(self):
+        rv = self.recycleview
+        if rv:
+            self.funbind('data', rv._dispatch_prop_on_source, 'data')
+        super(RecycleDataModel, self).detach_recycleview()
+
+    def _on_data_callback(self, instance, value):
+        last_len = self._last_len
+        new_len = self._last_len = len(self.data)
+        op, val = value.last_op
+
+        if op == '__setitem__':
+            val = recondition_slice_assign(val, last_len, new_len)
+            if val is not None:
+                self.dispatch('on_data_changed', modified=val)
+            else:
+                self.dispatch('on_data_changed')
+        elif op == '__delitem__':
+            self.dispatch('on_data_changed', removed=val)
+        elif op == '__setslice__':
+            val = recondition_slice_assign(slice(*val), last_len, new_len)
+            if val is not None:
+                self.dispatch('on_data_changed', modified=val)
+            else:
+                self.dispatch('on_data_changed')
+        elif op == '__delslice__':
+            self.dispatch('on_data_changed', removed=slice(*val))
+        elif op == '__iadd__' or op == '__imul__':
+            self.dispatch('on_data_changed', appended=slice(last_len, new_len))
+        elif op == 'append':
+            self.dispatch('on_data_changed', appended=slice(last_len, new_len))
+        elif op == 'insert':
+            self.dispatch('on_data_changed', inserted=val)
+        elif op == 'pop':
+            if val:
+                self.dispatch('on_data_changed', removed=val[0])
+            else:
+                self.dispatch('on_data_changed', removed=last_len - 1)
+        elif op == 'extend':
+            self.dispatch('on_data_changed', appended=slice(last_len, new_len))
+        else:
+            self.dispatch('on_data_changed')
diff --git a/kivy/uix/recycleview/layout.py b/kivy/uix/recycleview/layout.py
new file mode 100644
index 0000000..bb2de27
--- /dev/null
+++ b/kivy/uix/recycleview/layout.py
@@ -0,0 +1,253 @@
+'''
+RecycleView Layouts
+===================
+
+.. versionadded:: 1.10.0
+
+The Layouts handle the presentation of views for the
+:class:`~kivy.uix.recycleview.RecycleView`.
+
+.. warning::
+    This module is highly experimental, its API may change in the future and
+    the documentation is not complete at this time.
+'''
+from kivy.compat import string_types
+from kivy.factory import Factory
+from kivy.properties import StringProperty, ObjectProperty
+from kivy.uix.behaviors import CompoundSelectionBehavior
+from kivy.uix.recycleview.views import RecycleDataViewBehavior, \
+    _view_base_cache
+
+
+class LayoutChangeException(Exception):
+    pass
+
+
+class LayoutSelectionBehavior(CompoundSelectionBehavior):
+    '''The :class:`LayoutSelectionBehavior` can be combined with
+    :class:`RecycleLayoutManagerBehavior` to allow its derived classes
+    selection behaviors similarly to how
+    :class:`~kivy.uix.behaviors.compoundselection.CompoundSelectionBehavior`
+    can be used to add selection behaviors to normal layout.
+
+    :class:`RecycleLayoutManagerBehavior` manages its children
+    differently than normal layouts or widgets so this class adapts
+    :class:`~kivy.uix.behaviors.compoundselection.CompoundSelectionBehavior`
+    based selection to work with :class:`RecycleLayoutManagerBehavior` as well.
+
+    Similarly to
+    :class:`~kivy.uix.behaviors.compoundselection.CompoundSelectionBehavior`,
+    one can select using the keyboard or touch, which calls :meth:`select_node`
+    or :meth:`deselect_node`, or one can call these methods directly. When a
+    item is selected or deselected :meth:`apply_selection` is called. See
+    :meth:`apply_selection`.
+
+
+    '''
+
+    key_selection = StringProperty(None, allownone=True)
+    '''The key used to check whether a view of a data item can be selected
+    with touch or the keyboard.
+
+    :attr:`key_selection` is the key in data, which if present and ``True``
+    will enable selection for this item from the keyboard or with a touch.
+    When None, the default, not item will be selectable.
+
+    :attr:`key_selection` is a :class:`StringProperty` and defaults to None.
+
+    .. note::
+        All data items can be selected directly using :meth:`select_node` or
+        :meth:`deselect_node`, even if :attr:`key_selection` is False.
+    '''
+
+    _selectable_nodes = []
+    _nodes_map = {}
+
+    def __init__(self, **kwargs):
+        self.nodes_order_reversed = False
+        super(LayoutSelectionBehavior, self).__init__(**kwargs)
+
+    def compute_sizes_from_data(self, data, flags):
+        # overwrite this method so that when data changes we update
+        # selectable nodes.
+        key = self.key_selection
+        if key is None:
+            nodes = self._selectable_nodes = []
+        else:
+            nodes = self._selectable_nodes = [
+                i for i, d in enumerate(data) if d.get(key)]
+
+        self._nodes_map = {v: k for k, v in enumerate(nodes)}
+        return super(LayoutSelectionBehavior, self).compute_sizes_from_data(
+            data, flags)
+
+    def get_selectable_nodes(self):
+        # the indices of the data is used as the nodes
+        return self._selectable_nodes
+
+    def get_index_of_node(self, node, selectable_nodes):
+        # the indices of the data is used as the nodes, so node
+        return self._nodes_map[node]
+
+    def goto_node(self, key, last_node, last_node_idx):
+        node, idx = super(LayoutSelectionBehavior, self).goto_node(
+            key, last_node, last_node_idx)
+        if node is not last_node:
+            self.goto_view(node)
+        return node, idx
+
+    def select_node(self, node):
+        if super(LayoutSelectionBehavior, self).select_node(node):
+            view = self.recycleview.view_adapter.get_visible_view(node)
+            if view is not None:
+                self.apply_selection(node, view, True)
+
+    def deselect_node(self, node):
+        if super(LayoutSelectionBehavior, self).deselect_node(node):
+            view = self.recycleview.view_adapter.get_visible_view(node)
+            if view is not None:
+                self.apply_selection(node, view, False)
+
+    def apply_selection(self, index, view, is_selected):
+        '''Applies the selection to the view. This is called internally when
+        a view is displayed and it needs to be shown as selected or as not
+        selected.
+
+        It is called when :meth:`select_node` or :meth:`deselect_node` is
+        called or when a view needs to be refreshed. Its function is purely to
+        update the view to reflect the selection state. So the function may be
+        called multiple times even if the selection state may not have changed.
+
+        If the view is a instance of
+        :class:`~kivy.uix.recycleview.views.RecycleDataViewBehavior`, its
+        :meth:`~kivy.uix.recycleview.views.RecycleDataViewBehavior.\
+apply_selection` method will be called every time the view needs to refresh
+        the selection state. Otherwise, the this method is responsible
+        for applying the selection.
+
+        :Parameters:
+
+            `index`: int
+                The index of the data item that is associated with the view.
+            `view`: widget
+                The widget that is the view of this data item.
+            `is_selected`: bool
+                Whether the item is selected.
+        '''
+        viewclass = view.__class__
+        if viewclass not in _view_base_cache:
+            _view_base_cache[viewclass] = isinstance(view,
+                                                     RecycleDataViewBehavior)
+
+        if _view_base_cache[viewclass]:
+            view.apply_selection(self.recycleview, index, is_selected)
+
+    def refresh_view_layout(self, index, layout, view, viewport):
+        super(LayoutSelectionBehavior, self).refresh_view_layout(
+            index, layout, view, viewport)
+        self.apply_selection(index, view, index in self.selected_nodes)
+
+
+class RecycleLayoutManagerBehavior(object):
+    """A RecycleLayoutManagerBehavior is responsible for positioning views into
+    the :attr:`RecycleView.data` within a :class:`RecycleView`. It adds new
+    views into the data when it becomes visible to the user, and removes them
+    when they leave the visible area.
+    """
+
+    viewclass = ObjectProperty(None)
+    '''See :attr:`RecyclerView.viewclass`.
+    '''
+    key_viewclass = StringProperty(None)
+    '''See :attr:`RecyclerView.key_viewclass`.
+    '''
+
+    recycleview = ObjectProperty(None, allownone=True)
+
+    asked_sizes = None
+
+    def attach_recycleview(self, rv):
+        self.recycleview = rv
+        if rv:
+            fbind = self.fbind
+            # can be made more selective update than refresh_from_data which
+            # causes a full update. But this likely affects most of the data.
+            fbind('viewclass', rv.refresh_from_data)
+            fbind('key_viewclass', rv.refresh_from_data)
+            fbind('viewclass', rv._dispatch_prop_on_source, 'viewclass')
+            fbind('key_viewclass', rv._dispatch_prop_on_source,
+                  'key_viewclass')
+
+    def detach_recycleview(self):
+        self.clear_layout()
+        rv = self.recycleview
+        if rv:
+            funbind = self.funbind
+            funbind('viewclass', rv.refresh_from_data)
+            funbind('key_viewclass', rv.refresh_from_data)
+            funbind('viewclass', rv._dispatch_prop_on_source, 'viewclass')
+            funbind('key_viewclass', rv._dispatch_prop_on_source,
+                  'key_viewclass')
+        self.recycleview = None
+
+    def compute_sizes_from_data(self, data, flags):
+        pass
+
+    def compute_layout(self, data, flags):
+        pass
+
+    def compute_visible_views(self, data, viewport):
+        '''`viewport` is in coordinates of the layout manager.
+        '''
+        pass
+
+    def set_visible_views(self, indices, data, viewport):
+        '''`viewport` is in coordinates of the layout manager.
+        '''
+        pass
+
+    def refresh_view_layout(self, index, layout, view, viewport):
+        '''`See :meth:`~kivy.uix.recycleview.views.RecycleDataAdapter.\
+refresh_view_layout`.
+        '''
+        self.recycleview.view_adapter.refresh_view_layout(
+            index, layout, view, viewport)
+
+    def get_view_index_at(self, pos):
+        """Return the view `index` on which position, `pos`, falls.
+
+        `pos` is in coordinates of the layout manager.
+        """
+        pass
+
+    def remove_views(self):
+        rv = self.recycleview
+        if rv:
+            adapter = rv.view_adapter
+            if adapter:
+                adapter.make_views_dirty()
+
+    def remove_view(self, view, index):
+        rv = self.recycleview
+        if rv:
+            adapter = rv.view_adapter
+            if adapter:
+                adapter.make_view_dirty(view, index)
+
+    def clear_layout(self):
+        rv = self.recycleview
+        if rv:
+            adapter = rv.view_adapter
+            if adapter:
+                adapter.invalidate()
+
+    def goto_view(self, index):
+        '''Moves the views so that the view corresponding to `index` is
+        visible.
+        '''
+        pass
+
+    def on_viewclass(self, instance, value):
+        # resolve the real class if it was a string.
+        if isinstance(value, string_types):
+            self.viewclass = getattr(Factory, value)
diff --git a/kivy/uix/recycleview/views.py b/kivy/uix/recycleview/views.py
new file mode 100644
index 0000000..6212b03
--- /dev/null
+++ b/kivy/uix/recycleview/views.py
@@ -0,0 +1,423 @@
+'''
+RecycleView Views
+=================
+
+.. versionadded:: 1.10.0
+
+The adapter part of the RecycleView which together with the layout is the
+view part of the model-view-controller pattern.
+
+The view module handles converting the data to a view using the adapter class
+which is then displayed by the layout. A view can be any Widget based class.
+However, inheriting from RecycleDataViewBehavior adds methods for converting
+the data to a view.
+
+TODO:
+    * Make view caches specific to each view class type.
+
+'''
+
+from kivy.properties import ObjectProperty
+from kivy.event import EventDispatcher
+from collections import defaultdict
+
+__all__ = (
+    'RecycleDataViewBehavior', 'RecycleKVIDsDataViewBehavior',
+    'RecycleDataAdapter')
+
+_view_base_cache = {}
+'''Cache whose keys are classes and values is a boolean indicating whether the
+class inherits from :class:`RecycleDataViewBehavior`.
+'''
+
+_cached_views = defaultdict(list)
+'''A size limited cache that contains old views (instances) that are not used.
+Each key is a class whose value is the list of the instances of that class.
+'''
+# current number of unused classes in the class cache
+_cache_count = 0
+# maximum number of items in the class cache
+_max_cache_size = 1000
+
+
+def _clean_cache():
+    '''Trims _cached_views cache to half the size of `_max_cache_size`.
+    '''
+    # all keys will be reduced to max_size.
+    max_size = (_max_cache_size // 2) // len(_cached_views)
+    global _cache_count
+    for cls, instances in _cached_views.items():
+        _cache_count -= max(0, len(instances) - max_size)
+        del instances[max_size:]
+
+
+class RecycleDataViewBehavior(object):
+    '''A optional base class for data views (:attr:`RecycleView`.viewclass).
+    If a view inherits from this class, the class's functions will be called
+    when the view needs to be updated due to a data change or layout update.
+    '''
+
+    def refresh_view_attrs(self, rv, index, data):
+        '''Called by the :class:`RecycleAdapter` when the view is initially
+        populated with the values from the `data` dictionary for this item.
+
+        Any pos or size info should be removed because they are set
+        subsequently with :attr:`refresh_view_layout`.
+
+        :Parameters:
+
+            `rv`: :class:`RecycleView` instance
+                The :class:`RecycleView` that caused the update.
+            `data`: dict
+                The data dict used to populate this view.
+        '''
+        sizing_attrs = RecycleDataAdapter._sizing_attrs
+        for key, value in data.items():
+            if key not in sizing_attrs:
+                setattr(self, key, value)
+
+    def refresh_view_layout(self, rv, index, layout, viewport):
+        '''Called when the view's size is updated by the layout manager,
+        :class:`RecycleLayoutManagerBehavior`.
+
+        :Parameters:
+
+            `rv`: :class:`RecycleView` instance
+                The :class:`RecycleView` that caused the update.
+            `viewport`: 4-tuple
+                The coordinates of the bottom left and width height in layout
+                manager coordinates. This may be larger than this view item.
+
+        :raises:
+            `LayoutChangeException`: If the sizing or data changed during a
+            call to this method, raising a `LayoutChangeException` exception
+            will force a refresh. Useful when data changed and we don't want
+            to layout further since it'll be overwritten again soon.
+        '''
+        w, h = layout.pop('size')
+        if w is None:
+            if h is not None:
+                self.height = h
+        else:
+            if h is None:
+                self.width = w
+            else:
+                self.size = w, h
+
+        for name, value in layout.items():
+            setattr(self, name, value)
+
+    def apply_selection(self, rv, index, is_selected):
+        pass
+
+
+class RecycleKVIDsDataViewBehavior(RecycleDataViewBehavior):
+    """Similar to :class:`RecycleDataViewBehavior`, except that the data keys
+    can signify properties of an object named with an id in the root KV rule.
+
+    E.g. given a KV rule::
+
+        <MyRule@RecycleKVIDsDataViewBehavior+BoxLayout>:
+            Label:
+                id: name
+            Label:
+                id: value
+
+    Then setting the data list with
+    ``rv.data = [{'name.text': 'Kivy user', 'value.text': '12'}]`` would
+    automatically set the corresponding labels.
+
+    So, if the key doesn't have a period, the named property of the root widget
+    will be set to the corresponding value. If there is a period, the named
+    property of the widget with the id listed before the period will be set to
+    the corresponding value.
+
+    .. versionadded:: 2.0.0
+    """
+
+    def refresh_view_attrs(self, rv, index, data):
+        sizing_attrs = RecycleDataAdapter._sizing_attrs
+        for key, value in data.items():
+            if key not in sizing_attrs:
+                name, *ids = key.split('.')
+                if ids:
+                    if len(ids) != 1:
+                        raise ValueError(
+                            f'Data key "{key}" has more than one period')
+                    setattr(self.ids[name], ids[0], value)
+                else:
+                    setattr(self, name, value)
+
+
+class RecycleDataAdapter(EventDispatcher):
+    '''The class that converts data to a view.
+
+    --- Internal details ---
+    A view can have 3 states.
+
+        * It can be completely in sync with the data, which
+          occurs when the view is displayed. These are stored in :attr:`views`.
+        * It can be dirty, which occurs when the view is in sync with the data,
+          except for the size/pos parameters which is controlled by the layout.
+          This occurs when the view is not currently displayed but the data has
+          not changed. These views are stored in :attr:`dirty_views`.
+        * Finally the view can be dead which occurs when the data changes and
+          the view was not updated or when a view is just created. Such views
+          are typically added to the internal cache.
+
+    Typically what happens is that the layout manager lays out the data
+    and then asks for views, using :meth:`set_visible_views,` for some specific
+    data items that it displays.
+
+    These views are gotten from the current views, dirty or global cache. Then
+    depending on the view state :meth:`refresh_view_attrs` is called to bring
+    the view up to date with the data (except for sizing parameters). Finally,
+    the layout manager gets these views, updates their size and displays them.
+    '''
+
+    recycleview = ObjectProperty(None, allownone=True)
+    '''The :class:`~kivy.uix.recycleview.RecycleViewBehavior` associated
+    with this instance.
+    '''
+
+    # internals
+    views = {}  # current displayed items
+    # items whose attrs, except for pos/size is still accurate
+    dirty_views = defaultdict(dict)
+
+    _sizing_attrs = {
+        'size', 'width', 'height', 'size_hint', 'size_hint_x', 'size_hint_y',
+        'pos', 'x', 'y', 'center', 'center_x', 'center_y', 'pos_hint',
+        'size_hint_min', 'size_hint_min_x', 'size_hint_min_y', 'size_hint_max',
+        'size_hint_max_x', 'size_hint_max_y'}
+
+    def __init__(self, **kwargs):
+        """
+        Fix for issue https://github.com/kivy/kivy/issues/5913:
+        Scrolling RV A, then Scrolling RV B, content of A and B seemed
+        to be getting mixed up
+        """
+        self.views = {}
+        self.dirty_views = defaultdict(dict)
+        super(RecycleDataAdapter, self).__init__(**kwargs)
+
+    def attach_recycleview(self, rv):
+        '''Associates a :class:`~kivy.uix.recycleview.RecycleViewBehavior`
+        with this instance. It is stored in :attr:`recycleview`.
+        '''
+        self.recycleview = rv
+
+    def detach_recycleview(self):
+        '''Removes the :class:`~kivy.uix.recycleview.RecycleViewBehavior`
+        associated with this instance and clears :attr:`recycleview`.
+        '''
+        self.recycleview = None
+
+    def create_view(self, index, data_item, viewclass):
+        '''(internal) Creates and initializes the view for the data at `index`.
+
+        The returned view is synced with the data, except for the pos/size
+        information.
+        '''
+        if viewclass is None:
+            return
+
+        view = viewclass()
+        self.refresh_view_attrs(index, data_item, view)
+        return view
+
+    def get_view(self, index, data_item, viewclass):
+        '''(internal) Returns a view instance for the data at `index`
+
+        It looks through the various caches and finally creates a view if it
+        doesn't exist. The returned view is synced with the data, except for
+        the pos/size information.
+
+        If found in the cache it's removed from the source
+        before returning. It doesn't check the current views.
+        '''
+        # is it in the dirtied views?
+        dirty_views = self.dirty_views
+        if viewclass is None:
+            return
+        stale = False
+        view = None
+
+        if viewclass in dirty_views:  # get it first from dirty list
+            dirty_class = dirty_views[viewclass]
+            if index in dirty_class:
+                # we found ourself in the dirty list, no need to update data!
+                view = dirty_class.pop(index)
+            elif _cached_views[viewclass]:
+                # global cache has this class, update data
+                view, stale = _cached_views[viewclass].pop(), True
+            elif dirty_class:
+                # random any dirty view element - update data
+                view, stale = dirty_class.popitem()[1], True
+        elif _cached_views[viewclass]:  # otherwise go directly to cache
+            # global cache has this class, update data
+            view, stale = _cached_views[viewclass].pop(), True
+
+        if view is None:
+            view = self.create_view(index, data_item, viewclass)
+            if view is None:
+                return
+
+        if stale:
+            self.refresh_view_attrs(index, data_item, view)
+        return view
+
+    def refresh_view_attrs(self, index, data_item, view):
+        '''(internal) Syncs the view and brings it up to date with the data.
+
+        This method calls :meth:`RecycleDataViewBehavior.refresh_view_attrs`
+        if the view inherits from :class:`RecycleDataViewBehavior`. See that
+        method for more details.
+
+        .. note::
+            Any sizing and position info is skipped when syncing with the data.
+        '''
+        viewclass = view.__class__
+        if viewclass not in _view_base_cache:
+            _view_base_cache[viewclass] = isinstance(view,
+                                                     RecycleDataViewBehavior)
+
+        if _view_base_cache[viewclass]:
+            view.refresh_view_attrs(self.recycleview, index, data_item)
+        else:
+            sizing_attrs = RecycleDataAdapter._sizing_attrs
+            for key, value in data_item.items():
+                if key not in sizing_attrs:
+                    setattr(view, key, value)
+
+    def refresh_view_layout(self, index, layout, view, viewport):
+        '''Updates the sizing information of the view.
+
+        viewport is in coordinates of the layout manager.
+
+        This method calls :meth:`RecycleDataViewBehavior.refresh_view_attrs`
+        if the view inherits from :class:`RecycleDataViewBehavior`. See that
+        method for more details.
+
+        .. note::
+            Any sizing and position info is skipped when syncing with the data.
+        '''
+        if view.__class__ not in _view_base_cache:
+            _view_base_cache[view.__class__] = isinstance(
+                view, RecycleDataViewBehavior)
+
+        if _view_base_cache[view.__class__]:
+            view.refresh_view_layout(
+                self.recycleview, index, layout, viewport)
+        else:
+            w, h = layout.pop('size')
+            if w is None:
+                if h is not None:
+                    view.height = h
+            else:
+                if h is None:
+                    view.width = w
+                else:
+                    view.size = w, h
+
+            for name, value in layout.items():
+                setattr(view, name, value)
+
+    def make_view_dirty(self, view, index):
+        '''(internal) Used to flag this view as dirty, ready to be used for
+        others. See :meth:`make_views_dirty`.
+        '''
+        del self.views[index]
+        self.dirty_views[view.__class__][index] = view
+
+    def make_views_dirty(self):
+        '''Makes all the current views dirty.
+
+        Dirty views are still in sync with the corresponding data. However, the
+        size information may go out of sync. Therefore a dirty view can be
+        reused by the same index by just updating the sizing information.
+
+        Once the underlying data of this index changes, the view should be
+        removed from the dirty views and moved to the global cache with
+        :meth:`invalidate`.
+
+        This is typically called when the layout manager needs to re-layout all
+        the data.
+        '''
+        views = self.views
+        if not views:
+            return
+
+        dirty_views = self.dirty_views
+        for index, view in views.items():
+            dirty_views[view.__class__][index] = view
+        self.views = {}
+
+    def invalidate(self):
+        '''Moves all the current views into the global cache.
+
+        As opposed to making a view dirty where the view is in sync with the
+        data except for sizing information, this will completely disconnect the
+        view from the data, as it is assumed the data has gone out of sync with
+        the view.
+
+        This is typically called when the data changes.
+        '''
+        global _cache_count
+        for view in self.views.values():
+            _cached_views[view.__class__].append(view)
+            _cache_count += 1
+
+        for cls, views in self.dirty_views.items():
+            _cached_views[cls].extend(views.values())
+            _cache_count += len(views)
+
+        if _cache_count >= _max_cache_size:
+            _clean_cache()
+        self.views = {}
+        self.dirty_views.clear()
+
+    def set_visible_views(self, indices, data, viewclasses):
+        '''Gets a 3-tuple of the new, remaining, and old views for the current
+        viewport.
+
+        The new views are synced to the data except for the size/pos
+        properties.
+        The old views need to be removed from the layout, and the new views
+        added.
+
+        The new views are not necessarily *new*, but are all the currently
+        visible views.
+        '''
+        visible_views = {}
+        previous_views = self.views
+        ret_new = []
+        ret_remain = []
+        get_view = self.get_view
+
+        # iterate though the visible view
+        # add them into the container if not already done
+        for index in indices:
+            view = previous_views.pop(index, None)
+            if view is not None:  # was current view
+                visible_views[index] = view
+                ret_remain.append((index, view))
+            else:
+                view = get_view(index, data[index],
+                                viewclasses[index]['viewclass'])
+                if view is None:
+                    continue
+                visible_views[index] = view
+                ret_new.append((index, view))
+
+        old_views = previous_views.items()
+        self.make_views_dirty()
+        self.views = visible_views
+        return ret_new, ret_remain, old_views
+
+    def get_visible_view(self, index):
+        '''Returns the currently visible view associated with ``index``.
+
+        If no view is currently displayed for ``index`` it returns ``None``.
+        '''
+        return self.views.get(index)
diff --git a/kivy/uix/relativelayout.py b/kivy/uix/relativelayout.py
new file mode 100644
index 0000000..60b076b
--- /dev/null
+++ b/kivy/uix/relativelayout.py
@@ -0,0 +1,324 @@
+'''
+Relative Layout
+===============
+
+.. versionadded:: 1.4.0
+
+
+This layout allows you to set relative coordinates for children. If you want
+absolute positioning, use the :class:`~kivy.uix.floatlayout.FloatLayout`.
+
+The :class:`RelativeLayout` class behaves just like the regular
+:class:`FloatLayout` except that its child widgets are positioned relative to
+the layout.
+
+When a widget with position = (0,0) is added to a RelativeLayout,
+the child widget will also move when the position of the RelativeLayout
+is changed. The child widgets coordinates remain (0,0) as they are
+always relative to the parent layout.
+
+Coordinate Systems
+------------------
+
+Window coordinates
+~~~~~~~~~~~~~~~~~~
+
+By default, there's only one coordinate system that defines the position of
+widgets and touch events dispatched to them: the window coordinate system,
+which places (0, 0) at the bottom left corner of the window.
+Although there are other coordinate systems defined, e.g. local
+and parent coordinates, these coordinate systems are identical to the window
+coordinate system as long as a relative layout type widget is not in the
+widget's parent stack. When widget.pos is read or a touch is received,
+the coordinate values are in parent coordinates. But as mentioned, these are
+identical to window coordinates, even in complex widget stacks as long as
+there's no relative layout type widget in the widget's parent stack.
+
+For example:
+
+.. code-block:: kv
+
+    BoxLayout:
+        Label:
+            text: 'Left'
+        Button:
+            text: 'Middle'
+            on_touch_down: print('Middle: {}'.format(args[1].pos))
+        BoxLayout:
+            on_touch_down: print('Box: {}'.format(args[1].pos))
+            Button:
+                text: 'Right'
+                on_touch_down: print('Right: {}'.format(args[1].pos))
+
+When the middle button is clicked and the touch propagates through the
+different parent coordinate systems, it prints the following::
+
+    >>> Box: (430.0, 282.0)
+    >>> Right: (430.0, 282.0)
+    >>> Middle: (430.0, 282.0)
+
+As claimed, the touch has identical coordinates to the window coordinates
+in every coordinate system. :meth:`~kivy.uix.widget.Widget.collide_point`
+for example, takes the point in window coordinates.
+
+Parent coordinates
+~~~~~~~~~~~~~~~~~~
+
+Other :class:`RelativeLayout` type widgets are
+:class:`~kivy.uix.scatter.Scatter`,
+:class:`~kivy.uix.scatterlayout.ScatterLayout`,
+and :class:`~kivy.uix.scrollview.ScrollView`. If such a special widget is in
+the parent stack, only then does the parent and local coordinate system
+diverge from the window coordinate system. For each such widget in the stack,
+a coordinate system with (0, 0) of that coordinate system being at the bottom
+left corner of that widget is created. **Position and touch coordinates
+received and read by a widget are in the coordinate system of the most
+recent special widget in its parent stack (not including itself) or in window
+coordinates if there are none** (as in the first example). We call these
+coordinates parent coordinates.
+
+
+For example:
+
+.. code-block:: kv
+
+    BoxLayout:
+        Label:
+            text: 'Left'
+        Button:
+            text: 'Middle'
+            on_touch_down: print('Middle: {}'.format(args[1].pos))
+        RelativeLayout:
+            on_touch_down: print('Relative: {}'.format(args[1].pos))
+            Button:
+                text: 'Right'
+                on_touch_down: print('Right: {}'.format(args[1].pos))
+
+Clicking on the middle button prints::
+
+    >>> Relative: (396.0, 298.0)
+    >>> Right: (-137.33, 298.0)
+    >>> Middle: (396.0, 298.0)
+
+As the touch propagates through the widgets, for each widget, the
+touch is received in parent coordinates. Because both the relative and middle
+widgets don't have these special widgets in their parent stack, the touch is
+the same as window coordinates. Only the right widget, which has a
+RelativeLayout in its parent stack, receives the touch in coordinates relative
+to that RelativeLayout which is different than window coordinates.
+
+Local and Widget coordinates
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When expressed in parent coordinates, the position is expressed in the
+coordinates of the most recent special widget in its parent stack, not
+including itself. When expressed in local or widget coordinates, the widgets
+themselves are also included.
+
+Changing the above example to transform the parent coordinates into local
+coordinates:
+
+.. code-block:: kv
+
+    BoxLayout:
+        Label:
+            text: 'Left'
+        Button:
+            text: 'Middle'
+            on_touch_down: print('Middle: {}'.format(\
+self.to_local(*args[1].pos)))
+        RelativeLayout:
+            on_touch_down: print('Relative: {}'.format(\
+self.to_local(*args[1].pos)))
+            Button:
+                text: 'Right'
+                on_touch_down: print('Right: {}'.format(\
+self.to_local(*args[1].pos)))
+
+Now, clicking on the middle button prints::
+
+    >>> Relative: (-135.33, 301.0)
+    >>> Right: (-135.33, 301.0)
+    >>> Middle: (398.0, 301.0)
+
+This is because now the relative widget also expresses the coordinates
+relative to itself.
+
+.. note::
+
+    Although all widgets including :class:`RelativeLayout` receive their touch
+    events in ``on_touch_xxx`` in parent coordinates, these special widgets
+    will transform the touch position to be in local coordinates before it
+    calls ``super``. This may only be noticeable in a complex inheritance
+    class.
+
+Coordinate transformations
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+:class:`~kivy.uix.widget.Widget` provides 4 functions to transform coordinates
+between the various coordinate systems. For now, we assume that the `relative`
+keyword of these functions is `False`.
+:meth:`~kivy.uix.widget.Widget.to_widget` takes the coordinates expressed in
+window coordinates and returns them in local (widget) coordinates.
+:meth:`~kivy.uix.widget.Widget.to_window` takes the coordinates expressed in
+local coordinates and returns them in window coordinates.
+:meth:`~kivy.uix.widget.Widget.to_parent` takes the coordinates expressed in
+local coordinates and returns them in parent coordinates.
+:meth:`~kivy.uix.widget.Widget.to_local` takes the coordinates expressed in
+parent coordinates and returns them in local coordinates.
+
+Each of the 4 transformation functions take a `relative` parameter. When the
+relative parameter is True, the coordinates are returned or originate in
+true relative coordinates - relative to a coordinate system with its (0, 0) at
+the bottom left corner of the widget in question.
+
+.. _kivy-uix-relativelayout-common-pitfalls:
+
+Common Pitfalls
+---------------
+
+As all positions within a :class:`RelativeLayout` are relative to the position
+of the layout itself, the position of the layout should never be used in
+determining the position of sub-widgets or the layout's :attr:`canvas`.
+
+Take the following kv code for example:
+
+.. container:: align-right
+
+    .. figure:: images/relativelayout-fixedposition.png
+        :scale: 50%
+
+        expected result
+
+    .. figure:: images/relativelayout-doubleposition.png
+        :scale: 50%
+
+        actual result
+
+.. code-block:: kv
+
+    FloatLayout:
+        Widget:
+            size_hint: None, None
+            size: 200, 200
+            pos: 200, 200
+
+            canvas:
+                Color:
+                    rgba: 1, 1, 1, 1
+                Rectangle:
+                    pos: self.pos
+                    size: self.size
+
+        RelativeLayout:
+            size_hint: None, None
+            size: 200, 200
+            pos: 200, 200
+
+            canvas:
+                Color:
+                    rgba: 1, 0, 0, 0.5
+                Rectangle:
+                    pos: self.pos  # incorrect
+                    size: self.size
+
+You might expect this to render a single pink rectangle; however, the content
+of the :class:`RelativeLayout` is already transformed, so the use of
+`pos: self.pos` will double that transformation. In this case, using
+`pos: 0, 0` or omitting `pos` completely will provide the expected result.
+
+This also applies to the position of sub-widgets. Instead of positioning a
+:class:`~kivy.uix.widget.Widget` based on the layout's own position:
+
+.. code-block:: kv
+
+    RelativeLayout:
+        Widget:
+            pos: self.parent.pos
+        Widget:
+            center: self.parent.center
+
+use the :attr:`pos_hint` property:
+
+.. code-block:: kv
+
+    RelativeLayout:
+        Widget:
+            pos_hint: {'x': 0, 'y': 0}
+        Widget:
+            pos_hint: {'center_x': 0.5, 'center_y': 0.5}
+
+.. versionchanged:: 1.7.0
+    Prior to version 1.7.0, the :class:`RelativeLayout` was implemented as a
+    :class:`~kivy.uix.floatlayout.FloatLayout` inside a
+    :class:`~kivy.uix.scatter.Scatter`. This behaviour/widget has
+    been renamed to `ScatterLayout`. The :class:`RelativeLayout` now only
+    supports relative positions (and can't be rotated, scaled or translated on
+    a multitouch system using two or more fingers). This was done so that the
+    implementation could be optimized and avoid the heavier calculations of
+    :class:`Scatter` (e.g. inverse matrix, recalculating multiple properties
+    etc.)
+
+'''
+
+__all__ = ('RelativeLayout', )
+
+from kivy.uix.floatlayout import FloatLayout
+
+
+class RelativeLayout(FloatLayout):
+    '''RelativeLayout class, see module documentation for more information.
+    '''
+
+    def __init__(self, **kw):
+        super(RelativeLayout, self).__init__(**kw)
+        funbind = self.funbind
+        trigger = self._trigger_layout
+        funbind('pos', trigger)
+        funbind('pos_hint', trigger)
+
+    def do_layout(self, *args):
+        super(RelativeLayout, self).do_layout(pos=(0, 0))
+
+    def to_parent(self, x, y, **k):
+        return (x + self.x, y + self.y)
+
+    def to_local(self, x, y, **k):
+        return (x - self.x, y - self.y)
+
+    def _apply_transform(self, m, pos=None):
+        m.translate(self.x, self.y, 0)
+        return super(RelativeLayout, self)._apply_transform(m, (0, 0))
+
+    def on_motion(self, etype, me):
+        if me.type_id in self.motion_filter and 'pos' in me.profile:
+            me.push()
+            me.apply_transform_2d(self.to_local)
+            ret = super().on_motion(etype, me)
+            me.pop()
+            return ret
+        return super().on_motion(etype, me)
+
+    def on_touch_down(self, touch):
+        x, y = touch.x, touch.y
+        touch.push()
+        touch.apply_transform_2d(self.to_local)
+        ret = super(RelativeLayout, self).on_touch_down(touch)
+        touch.pop()
+        return ret
+
+    def on_touch_move(self, touch):
+        x, y = touch.x, touch.y
+        touch.push()
+        touch.apply_transform_2d(self.to_local)
+        ret = super(RelativeLayout, self).on_touch_move(touch)
+        touch.pop()
+        return ret
+
+    def on_touch_up(self, touch):
+        x, y = touch.x, touch.y
+        touch.push()
+        touch.apply_transform_2d(self.to_local)
+        ret = super(RelativeLayout, self).on_touch_up(touch)
+        touch.pop()
+        return ret
diff --git a/kivy/uix/rst.py b/kivy/uix/rst.py
new file mode 100644
index 0000000..0de6e88
--- /dev/null
+++ b/kivy/uix/rst.py
@@ -0,0 +1,1492 @@
+'''
+reStructuredText renderer
+=========================
+
+.. versionadded:: 1.1.0
+
+`reStructuredText <http://docutils.sourceforge.net/rst.html>`_ is an
+easy-to-read, what-you-see-is-what-you-get plaintext markup syntax and parser
+system.
+
+.. note::
+
+    This widget requires the ``docutils`` package to run. Install it with
+    ``pip`` or include it as one of your deployment requirements.
+
+.. warning::
+
+    This widget is highly experimental. The styling and implementation should
+    not be considered stable until this warning has been removed.
+
+Usage with Text
+---------------
+
+::
+
+    text = """
+    .. _top:
+
+    Hello world
+    ===========
+
+    This is an **emphased text**, some ``interpreted text``.
+    And this is a reference to top_::
+
+        $ print("Hello world")
+
+    """
+    document = RstDocument(text=text)
+
+The rendering will output:
+
+.. image:: images/rstdocument.png
+
+Usage with Source
+-----------------
+
+You can also render a rst file using the :attr:`~RstDocument.source` property::
+
+    document = RstDocument(source='index.rst')
+
+You can reference other documents using the role ``:doc:``. For example, in the
+document ``index.rst`` you can write::
+
+    Go to my next document: :doc:`moreinfo.rst`
+
+It will generate a link that, when clicked, opens the ``moreinfo.rst``
+document.
+
+'''
+
+__all__ = ('RstDocument', )
+
+import os
+from os.path import dirname, join, exists, abspath
+from kivy.clock import Clock
+from kivy.compat import PY2
+from kivy.properties import ObjectProperty, NumericProperty, \
+    DictProperty, ListProperty, StringProperty, \
+    BooleanProperty, OptionProperty, AliasProperty
+from kivy.lang import Builder
+from kivy.utils import get_hex_from_color, get_color_from_hex
+from kivy.uix.widget import Widget
+from kivy.uix.scrollview import ScrollView
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.label import Label
+from kivy.uix.image import AsyncImage, Image
+from kivy.uix.videoplayer import VideoPlayer
+from kivy.uix.anchorlayout import AnchorLayout
+from kivy.animation import Animation
+from kivy.logger import Logger
+from docutils.parsers import rst
+from docutils.parsers.rst import roles
+from docutils import nodes, frontend, utils
+from docutils.parsers.rst import Directive, directives
+from docutils.parsers.rst.roles import set_classes
+
+
+#
+# Handle some additional roles
+#
+if 'KIVY_DOC' not in os.environ:
+
+    class role_doc(nodes.Inline, nodes.TextElement):
+        pass
+
+    class role_video(nodes.General, nodes.TextElement):
+        pass
+
+    class VideoDirective(Directive):
+        has_content = False
+        required_arguments = 1
+        optional_arguments = 0
+        final_argument_whitespace = True
+        option_spec = {'width': directives.nonnegative_int,
+                       'height': directives.nonnegative_int}
+
+        def run(self):
+            set_classes(self.options)
+            node = role_video(source=self.arguments[0], **self.options)
+            return [node]
+
+    generic_docroles = {
+        'doc': role_doc}
+
+    for rolename, nodeclass in generic_docroles.items():
+        generic = roles.GenericRole(rolename, nodeclass)
+        role = roles.CustomRole(rolename, generic, {'classes': [rolename]})
+        roles.register_local_role(rolename, role)
+
+    directives.register_directive('video', VideoDirective)
+
+Builder.load_string('''
+#:import parse_color kivy.parser.parse_color
+
+
+
+<RstDocument>:
+    content: content
+    scatter: scatter
+    do_scroll_x: False
+    canvas.before:
+        Color:
+            rgba: parse_color(root.colors['background'])
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+    Scatter:
+        id: scatter
+        size_hint_y: None
+        height: content.minimum_height
+        width: root.width
+        scale: 1
+        do_translation: False, False
+        do_scale: False
+        do_rotation: False
+
+        GridLayout:
+            id: content
+            cols: 1
+            height: self.minimum_height
+            width: root.width
+            padding: 10
+
+<RstTitle>:
+    markup: True
+    valign: 'top'
+    font_size:
+        sp(self.document.base_font_size - self.section * (
+        self.document.base_font_size / 31.0 * 2))
+    size_hint_y: None
+    height: self.texture_size[1] + dp(20)
+    text_size: self.width, None
+    bold: True
+
+    canvas:
+        Color:
+            rgba: parse_color(self.document.underline_color)
+        Rectangle:
+            pos: self.x, self.y + 5
+            size: self.width, 1
+
+
+<RstParagraph>:
+    markup: True
+    valign: 'top'
+    size_hint_y: None
+    height: self.texture_size[1] + self.my
+    text_size: self.width - self.mx, None
+    font_size: sp(self.document.base_font_size / 2.0)
+
+<RstTerm>:
+    size_hint: None, None
+    height: label.height
+    anchor_x: 'left'
+    Label:
+        id: label
+        text: root.text
+        markup: True
+        valign: 'top'
+        size_hint: None, None
+        size: self.texture_size[0] + dp(10), self.texture_size[1] + dp(10)
+        font_size: sp(root.document.base_font_size / 2.0)
+
+<RstBlockQuote>:
+    cols: 2
+    content: content
+    size_hint_y: None
+    height: content.height
+    Widget:
+        size_hint_x: None
+        width: 20
+    GridLayout:
+        id: content
+        cols: 1
+        size_hint_y: None
+        height: self.minimum_height
+
+<RstLiteralBlock>:
+    cols: 1
+    content: content
+    size_hint_y: None
+    height: content.texture_size[1] + dp(20)
+    canvas:
+        Color:
+            rgb: parse_color('#cccccc')
+        Rectangle:
+            pos: self.x - 1, self.y - 1
+            size: self.width + 2, self.height + 2
+        Color:
+            rgb: parse_color('#eeeeee')
+        Rectangle:
+            pos: self.pos
+            size: self.size
+    Label:
+        id: content
+        markup: True
+        valign: 'top'
+        text_size: self.width - 20, None
+        font_name: 'data/fonts/RobotoMono-Regular.ttf'
+        color: (0, 0, 0, 1)
+
+<RstList>:
+    cols: 2
+    size_hint_y: None
+    height: self.minimum_height
+
+<RstListItem>:
+    cols: 1
+    size_hint_y: None
+    height: self.minimum_height
+
+<RstSystemMessage>:
+    cols: 1
+    size_hint_y: None
+    height: self.minimum_height
+    canvas:
+        Color:
+            rgba: 1, 0, 0, .3
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+<RstWarning>:
+    content: content
+    cols: 1
+    padding: 20
+    size_hint_y: None
+    height: self.minimum_height
+    canvas:
+        Color:
+            rgba: 1, 0, 0, .5
+        Rectangle:
+            pos: self.x + 10, self.y + 10
+            size: self.width - 20, self.height - 20
+    GridLayout:
+        cols: 1
+        id: content
+        size_hint_y: None
+        height: self.minimum_height
+
+<RstNote>:
+    content: content
+    cols: 1
+    padding: 20
+    size_hint_y: None
+    height: self.minimum_height
+    canvas:
+        Color:
+            rgba: 0, 1, 0, .5
+        Rectangle:
+            pos: self.x + 10, self.y + 10
+            size: self.width - 20, self.height - 20
+    GridLayout:
+        cols: 1
+        id: content
+        size_hint_y: None
+        height: self.minimum_height
+
+<RstImage>:
+    size_hint: None, None
+    size: self.texture_size[0], self.texture_size[1] + dp(10)
+
+<RstAsyncImage>:
+    size_hint: None, None
+    size: self.texture_size[0], self.texture_size[1] + dp(10)
+
+<RstDefinitionList>:
+    cols: 1
+    size_hint_y: None
+    height: self.minimum_height
+    font_size: sp(self.document.base_font_size / 2.0)
+
+<RstDefinition>:
+    cols: 2
+    size_hint_y: None
+    height: self.minimum_height
+    font_size: sp(self.document.base_font_size / 2.0)
+
+<RstFieldList>:
+    cols: 2
+    size_hint_y: None
+    height: self.minimum_height
+
+<RstFieldName>:
+    markup: True
+    valign: 'top'
+    size_hint: 0.2, 1
+    color: (0, 0, 0, 1)
+    bold: True
+    text_size: self.width - 10, self.height - 10
+    valign: 'top'
+    font_size: sp(self.document.base_font_size / 2.0)
+
+<RstFieldBody>:
+    cols: 1
+    size_hint_y: None
+    height: self.minimum_height
+
+<RstFootnote>:
+    cols: 2
+    size_hint_y: None
+    height: self.minimum_height
+
+<RstFootName>:
+    markup: True
+    valign: 'top'
+    size_hint: 0.2, 1
+    color: (0, 0, 0, 1)
+    bold: True
+    text_size: self.width - 10, self.height - 10
+    valign: 'top'
+    font_size: sp(self.document.base_font_size / 2.0)
+
+<RstTable>:
+    size_hint_y: None
+    height: self.minimum_height
+
+<RstEntry>:
+    cols: 1
+    size_hint_y: None
+    height: self.minimum_height
+
+    canvas:
+        Color:
+            rgb: .2, .2, .2
+        Line:
+            points: [\
+            self.x,\
+            self.y,\
+            self.right,\
+            self.y,\
+            self.right,\
+            self.top,\
+            self.x,\
+            self.top,\
+            self.x,\
+            self.y]
+
+<RstTransition>:
+    size_hint_y: None
+    height: 20
+    canvas:
+        Color:
+            rgb: .2, .2, .2
+        Line:
+            points: [self.x, self.center_y, self.right, self.center_y]
+
+<RstListBullet>:
+    markup: True
+    valign: 'top'
+    size_hint_x: None
+    width: self.texture_size[0] + dp(10)
+    text_size: None, self.height - dp(10)
+    font_size: sp(self.document.base_font_size / 2.0)
+
+<RstEmptySpace>:
+    size_hint: 0.01, 0.01
+
+<RstDefinitionSpace>:
+    size_hint: None, 0.1
+    width: 50
+    font_size: sp(self.document.base_font_size / 2.0)
+
+<RstVideoPlayer>:
+    options: {'allow_stretch': True}
+    canvas.before:
+        Color:
+            rgba: (1, 1, 1, 1)
+        BorderImage:
+            source: 'atlas://data/images/defaulttheme/player-background'
+            pos: self.x - 25, self.y - 25
+            size: self.width + 50, self.height + 50
+            border: (25, 25, 25, 25)
+''')
+
+
+class RstVideoPlayer(VideoPlayer):
+    pass
+
+
+class RstDocument(ScrollView):
+    '''Base widget used to store an Rst document. See module documentation for
+    more information.
+    '''
+    source = StringProperty(None)
+    '''Filename of the RST document.
+
+    :attr:`source` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    source_encoding = StringProperty('utf-8')
+    '''Encoding to be used for the :attr:`source` file.
+
+    :attr:`source_encoding` is a :class:`~kivy.properties.StringProperty` and
+    defaults to `utf-8`.
+
+    .. Note::
+        It is your responsibility to ensure that the value provided is a
+        valid codec supported by python.
+    '''
+
+    source_error = OptionProperty('strict',
+                                  options=('strict', 'ignore', 'replace',
+                                           'xmlcharrefreplace',
+                                           'backslashreplac'))
+    '''Error handling to be used while encoding the :attr:`source` file.
+
+    :attr:`source_error` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to `strict`. Can be one of 'strict', 'ignore', 'replace',
+    'xmlcharrefreplace' or 'backslashreplac'.
+    '''
+
+    text = StringProperty(None)
+    '''RST markup text of the document.
+
+    :attr:`text` is a :class:`~kivy.properties.StringProperty` and defaults to
+    None.
+    '''
+
+    document_root = StringProperty(None)
+    '''Root path where :doc: will search for rst documents. If no path is
+    given, it will use the directory of the first loaded source file.
+
+    :attr:`document_root` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    base_font_size = NumericProperty(31)
+    '''Font size for the biggest title, 31 by default. All other font sizes are
+    derived from this.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    show_errors = BooleanProperty(False)
+    '''Indicate whether RST parsers errors should be shown on the screen
+    or not.
+
+    :attr:`show_errors` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    def _get_bgc(self):
+        return get_color_from_hex(self.colors.background)
+
+    def _set_bgc(self, value):
+        self.colors.background = get_hex_from_color(value)[1:]
+
+    background_color = AliasProperty(_get_bgc, _set_bgc,
+                                     bind=('colors',),
+                                     cache=True)
+    '''Specifies the background_color to be used for the RstDocument.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background_color` is an :class:`~kivy.properties.AliasProperty`
+    for colors['background'].
+    '''
+
+    colors = DictProperty({
+        'background': 'e5e6e9ff',
+        'link': 'ce5c00ff',
+        'paragraph': '202020ff',
+        'title': '204a87ff',
+        'bullet': '000000ff'})
+    '''Dictionary of all the colors used in the RST rendering.
+
+    .. warning::
+
+        This dictionary is needs special handling. You also need to call
+        :meth:`RstDocument.render` if you change them after loading.
+
+    :attr:`colors` is a :class:`~kivy.properties.DictProperty`.
+    '''
+
+    title = StringProperty('')
+    '''Title of the current document.
+
+    :attr:`title` is a :class:`~kivy.properties.StringProperty` and defaults to
+    ''. It is read-only.
+    '''
+
+    toctrees = DictProperty({})
+    '''Toctree of all loaded or preloaded documents. This dictionary is filled
+    when a rst document is explicitly loaded or where :meth:`preload` has been
+    called.
+
+    If the document has no filename, e.g. when the document is loaded from a
+    text file, the key will be ''.
+
+    :attr:`toctrees` is a :class:`~kivy.properties.DictProperty` and defaults
+    to {}.
+    '''
+
+    underline_color = StringProperty('204a9699')
+    '''underline color of the titles, expressed in html color notation
+
+    :attr:`underline_color` is a
+    :class:`~kivy.properties.StringProperty` and defaults to '204a9699'.
+
+    .. versionadded: 1.9.0
+    '''
+
+    # internals.
+    content = ObjectProperty(None)
+    scatter = ObjectProperty(None)
+    anchors_widgets = ListProperty([])
+    refs_assoc = DictProperty({})
+
+    def __init__(self, **kwargs):
+        self._trigger_load = Clock.create_trigger(self._load_from_text, -1)
+        self._parser = rst.Parser()
+        self._settings = frontend.OptionParser(
+            components=(rst.Parser, )).get_default_values()
+        super(RstDocument, self).__init__(**kwargs)
+
+    def on_source(self, instance, value):
+        if not value:
+            return
+        if self.document_root is None:
+            # set the documentation root to the directory name of the
+            # first tile
+            self.document_root = abspath(dirname(value))
+        self._load_from_source()
+
+    def on_text(self, instance, value):
+        self._trigger_load()
+
+    def render(self):
+        '''Force document rendering.
+        '''
+        self._load_from_text()
+
+    def resolve_path(self, filename):
+        '''Get the path for this filename. If the filename doesn't exist,
+        it returns the document_root + filename.
+        '''
+        if exists(filename):
+            return filename
+        return join(self.document_root, filename)
+
+    def preload(self, filename, encoding='utf-8', errors='strict'):
+        '''Preload a rst file to get its toctree and its title.
+
+        The result will be stored in :attr:`toctrees` with the ``filename`` as
+        key.
+        '''
+
+        with open(filename, 'rb') as fd:
+            text = fd.read().decode(encoding, errors)
+        # parse the source
+        document = utils.new_document('Document', self._settings)
+        self._parser.parse(text, document)
+        # fill the current document node
+        visitor = _ToctreeVisitor(document)
+        document.walkabout(visitor)
+        self.toctrees[filename] = visitor.toctree
+        return text
+
+    def _load_from_source(self):
+        filename = self.resolve_path(self.source)
+        self.text = self.preload(filename,
+                                 self.source_encoding,
+                                 self.source_error)
+
+    def _load_from_text(self, *largs):
+        try:
+            # clear the current widgets
+            self.content.clear_widgets()
+            self.anchors_widgets = []
+            self.refs_assoc = {}
+
+            # parse the source
+            document = utils.new_document('Document', self._settings)
+            text = self.text
+            if PY2 and type(text) is str:
+                text = text.decode('utf-8')
+            self._parser.parse(text, document)
+
+            # fill the current document node
+            visitor = _Visitor(self, document)
+            document.walkabout(visitor)
+
+            self.title = visitor.title or 'No title'
+        except:
+            Logger.exception('Rst: error while loading text')
+
+    def on_ref_press(self, node, ref):
+        self.goto(ref)
+
+    def goto(self, ref, *largs):
+        '''Scroll to the reference. If it's not found, nothing will be done.
+
+        For this text::
+
+            .. _myref:
+
+            This is something I always wanted.
+
+        You can do::
+
+            from kivy.clock import Clock
+            from functools import partial
+
+            doc = RstDocument(...)
+            Clock.schedule_once(partial(doc.goto, 'myref'), 0.1)
+
+        .. note::
+
+            It is preferable to delay the call of the goto if you just loaded
+            the document because the layout might not be finished or the
+            size of the RstDocument has not yet been determined. In
+            either case, the calculation of the scrolling would be
+            wrong.
+
+            You can, however, do a direct call if the document is already
+            loaded.
+
+        .. versionadded:: 1.3.0
+        '''
+        # check if it's a file ?
+        if ref.endswith('.rst'):
+            # whether it's a valid or invalid file, let source deal with it
+            self.source = ref
+            return
+
+        # get the association
+        ref = self.refs_assoc.get(ref, ref)
+
+        # search into all the nodes containing anchors
+        ax = ay = None
+        for node in self.anchors_widgets:
+            if ref in node.anchors:
+                ax, ay = node.anchors[ref]
+                break
+
+        # not found, stop here
+        if ax is None:
+            return
+
+        # found, calculate the real coordinate
+
+        # get the anchor coordinate inside widget space
+        ax += node.x
+        ay = node.top - ay
+        # ay += node.y
+
+        # what's the current coordinate for us?
+        sx, sy = self.scatter.x, self.scatter.top
+        # ax, ay = self.scatter.to_parent(ax, ay)
+
+        ay -= self.height
+
+        dx, dy = self.convert_distance_to_scroll(0, ay)
+        dy = max(0, min(1, dy))
+        Animation(scroll_y=dy, d=.25, t='in_out_expo').start(self)
+
+    def add_anchors(self, node):
+        self.anchors_widgets.append(node)
+
+
+class RstTitle(Label):
+
+    section = NumericProperty(0)
+
+    document = ObjectProperty(None)
+
+
+class RstParagraph(Label):
+
+    mx = NumericProperty(10)
+
+    my = NumericProperty(10)
+
+    document = ObjectProperty(None)
+
+
+class RstTerm(AnchorLayout):
+
+    text = StringProperty('')
+
+    document = ObjectProperty(None)
+
+
+class RstBlockQuote(GridLayout):
+    content = ObjectProperty(None)
+
+
+class RstLiteralBlock(GridLayout):
+    content = ObjectProperty(None)
+
+
+class RstList(GridLayout):
+    pass
+
+
+class RstListItem(GridLayout):
+    content = ObjectProperty(None)
+
+
+class RstListBullet(Label):
+
+    document = ObjectProperty(None)
+
+
+class RstSystemMessage(GridLayout):
+    pass
+
+
+class RstWarning(GridLayout):
+    content = ObjectProperty(None)
+
+
+class RstNote(GridLayout):
+    content = ObjectProperty(None)
+
+
+class RstImage(Image):
+    pass
+
+
+class RstAsyncImage(AsyncImage):
+    pass
+
+
+class RstDefinitionList(GridLayout):
+
+    document = ObjectProperty(None)
+
+
+class RstDefinition(GridLayout):
+
+    document = ObjectProperty(None)
+
+
+class RstFieldList(GridLayout):
+    pass
+
+
+class RstFieldName(Label):
+
+    document = ObjectProperty(None)
+
+
+class RstFieldBody(GridLayout):
+    pass
+
+
+class RstFootnote(GridLayout):
+    pass
+
+
+class RstFootName(Label):
+
+    document = ObjectProperty(None)
+
+
+class RstGridLayout(GridLayout):
+    pass
+
+
+class RstTable(GridLayout):
+    pass
+
+
+class RstEntry(GridLayout):
+    pass
+
+
+class RstTransition(Widget):
+    pass
+
+
+class RstEmptySpace(Widget):
+    pass
+
+
+class RstDefinitionSpace(Widget):
+
+    document = ObjectProperty(None)
+
+
+class _ToctreeVisitor(nodes.NodeVisitor):
+
+    def __init__(self, *largs):
+        self.toctree = self.current = []
+        self.queue = []
+        self.text = ''
+        nodes.NodeVisitor.__init__(self, *largs)
+
+    def push(self, tree):
+        self.queue.append(tree)
+        self.current = tree
+
+    def pop(self):
+        self.current = self.queue.pop()
+
+    def dispatch_visit(self, node):
+        cls = node.__class__
+        if cls is nodes.section:
+            section = {
+                'ids': node['ids'],
+                'names': node['names'],
+                'title': '',
+                'children': []}
+            if isinstance(self.current, dict):
+                self.current['children'].append(section)
+            else:
+                self.current.append(section)
+            self.push(section)
+        elif cls is nodes.title:
+            self.text = ''
+        elif cls is nodes.Text:
+            self.text += node
+
+    def dispatch_departure(self, node):
+        cls = node.__class__
+        if cls is nodes.section:
+            self.pop()
+        elif cls is nodes.title:
+            self.current['title'] = self.text
+
+
+class _Visitor(nodes.NodeVisitor):
+
+    def __init__(self, root, *largs):
+        self.root = root
+        self.title = None
+        self.current_list = []
+        self.current = None
+        self.idx_list = None
+        self.text = ''
+        self.text_have_anchor = False
+        self.section = 0
+        self.do_strip_text = False
+        self.substitution = {}
+
+        # store refblock here while building
+        self.foot_refblock = None
+
+        # store order for autonum/sym footnotes+refs
+        self.footnotes = {
+            'autonum': 0,
+            'autosym': 0,
+            'autonum_ref': 0,
+            'autosym_ref': 0,
+        }
+
+        # last four default chars aren't in our Roboto font,
+        # those were replaced with something else
+        self.footlist = [
+            '\u002A',  # asterisk
+            '\u2020',  # dagger
+            '\u2021',  # doubledagger
+            '\u00A7',  # section
+            '\u00B6',  # pilcrow
+            '\u0023',  # number
+            '\u2206',  # cap delta
+            '\u220F',  # cap pi
+            '\u0470',  # cap psi
+            '\u0466',  # cap yus
+        ]
+        nodes.NodeVisitor.__init__(self, *largs)
+
+    def push(self, widget):
+        self.current_list.append(self.current)
+        self.current = widget
+
+    def pop(self):
+        self.current = self.current_list.pop()
+
+    def brute_refs(self, node):
+        # get foot/cit refs manually because the output from
+        # docutils' parser doesn't contain any of these:
+        # node's refid, refname, backref, ... and/or are just ''/[]
+
+        def get_refs(condition, backref=False):
+            # backref=True is used in nodes.footnote
+            autonum = autosym = 0
+            _nodes = node.traverse(condition=condition, ascend=False)
+
+            for f in _nodes:
+                id = f['ids'][0]
+                auto = ''
+                if 'auto' in f:
+                    auto = f['auto']
+
+                # auto is either 1(int) or '*'
+                if auto == 1:
+                    autonum += 1
+                    key = 'backref' + str(autonum) if backref else str(autonum)
+                    self.root.refs_assoc[key] = id
+                elif auto == '*':
+                    sym = self.footlist[
+                        autosym % 10
+                    ] * (int(autosym / 10) + 1)
+                    key = 'backref' + sym if backref else sym
+                    self.root.refs_assoc[key] = id
+                    autosym += 1
+                else:
+                    if not backref:
+                        key = f['names'][0]
+                        if key:
+                            self.root.refs_assoc[key] = id
+                        continue
+
+                    key = 'backref' + f['refname'][0]
+
+                    if key in self.root.refs_assoc:
+                        self.root.refs_assoc[key].append(id)
+                    else:
+                        self.root.refs_assoc[key] = [id, ]
+
+        # these are unique and need to go FIRST
+        get_refs(nodes.footnote, backref=False)
+
+        # autonum & autosym are unique
+        get_refs(nodes.footnote_reference, backref=True)
+
+    def dispatch_visit(self, node):
+        cls = node.__class__
+        if cls is nodes.document:
+            self.push(self.root.content)
+            self.brute_refs(node)
+
+        elif cls is nodes.comment:
+            return
+
+        elif cls is nodes.section:
+            self.section += 1
+
+        elif cls is nodes.substitution_definition:
+            name = node.attributes['names'][0]
+            self.substitution[name] = node.children[0]
+
+        elif cls is nodes.substitution_reference:
+            node = self.substitution[node.attributes['refname']]
+            # it can be e.g. image or something else too!
+            if isinstance(node, nodes.Text):
+                self.text += node
+
+        elif cls is nodes.footnote:
+            # .. [x] footnote
+            text = ''
+            foot = RstFootnote()
+            ids = node.attributes['ids']
+            self.current.add_widget(foot)
+            self.push(foot)
+
+            # check if its autonumbered
+            auto = ''
+            if 'auto' in node.attributes:
+                auto = node.attributes['auto']
+
+            # auto is either 1(int) or '*'
+            if auto == 1:
+                self.footnotes['autonum'] += 1
+                name = str(self.footnotes['autonum'])
+                node_id = node.attributes['ids'][0]
+            elif auto == '*':
+                autosym = self.footnotes['autosym']
+                name = self.footlist[
+                    autosym % 10
+                ] * (int(autosym / 10) + 1)
+                self.footnotes['autosym'] += 1
+                node_id = node.attributes['ids'][0]
+            else:
+                # can have multiple refs:
+                # [8] (1, 2) Footnote ref
+                name = node.attributes['names'][0]
+                node_id = node['ids'][0]
+
+            # we can have a footnote without any link or ref
+            # .. [1] Empty footnote
+            link = self.root.refs_assoc.get(name, '')
+
+            # handle no refs
+            ref = self.root.refs_assoc.get('backref' + name, '')
+
+            # colorize only with refs
+            colorized = self.colorize(name, 'link') if ref else name
+
+            # has no refs
+            if not ref:
+                text = '&bl;%s&br;' % (colorized)
+            # list of refs
+            elif ref and isinstance(ref, list):
+                ref_block = [
+                    '[ref=%s][u]%s[/u][/ref]' % (r, i + 1)
+                    for i, r in enumerate(ref)
+                ]
+                # [1] ( 1, 2, ...) Footnote
+                self.foot_refblock = ''.join([
+                    '[i]( ', ', '.join(ref_block), ' )[/i]'
+                ])
+
+                text = '[anchor=%s]&bl;%s&br;' % (
+                    node['ids'][0], colorized
+                )
+            # single ref
+            else:
+                text = '[anchor=%s][ref=%s]&bl;%s&br;[/ref]' % (
+                    node['ids'][0], ref, colorized
+                )
+
+            name = RstFootName(
+                document=self.root,
+                text=text,
+            )
+            self.current.add_widget(name)
+            # give it anchor + event manually
+            self.root.add_anchors(name)
+            name.bind(on_ref_press=self.root.on_ref_press)
+
+        elif cls is nodes.footnote_reference:
+            self.text += '&bl;'
+            text = ''
+            name = ''
+
+            # check if its autonumbered
+            auto = ''
+            if 'auto' in node.attributes:
+                auto = node.attributes['auto']
+
+            # auto is either 1(int) or '*'
+            if auto == 1:
+                self.footnotes['autonum_ref'] += 1
+                name = str(self.footnotes['autonum_ref'])
+                node_id = node.attributes['ids'][0]
+            elif auto == '*':
+                autosym = self.footnotes['autosym_ref']
+                name = self.footlist[
+                    autosym % 10
+                ] * (int(autosym / 10) + 1)
+                self.footnotes['autosym_ref'] += 1
+                node_id = node.attributes['ids'][0]
+            else:
+                # can have multiple refs:
+                # [8] (1, 2) Footnote ref
+                name = node.children[0]
+                node_id = node['ids'][0]
+            text += name
+
+            refs = self.root.refs_assoc.get(name, '')
+            if not refs and auto in (1, '*'):
+                # parser should trigger it when checking
+                # for backlinks, but we don't have **any** refs
+                # to work with, so we have to trigger it manually
+                raise Exception(
+                    'Too many autonumbered or autosymboled '
+                    'footnote references!'
+                )
+
+            # has a single or no refs ( '' )
+            text = '[anchor=%s][ref=%s][color=%s]%s' % (
+                node_id, refs,
+                self.root.colors.get(
+                    'link', self.root.colors.get('paragraph')
+                ),
+                text
+            )
+            self.text += text
+            self.text_have_anchor = True
+
+        elif cls is nodes.title:
+            label = RstTitle(section=self.section, document=self.root)
+            self.current.add_widget(label)
+            self.push(label)
+            # assert(self.text == '')
+
+        elif cls is nodes.Text:
+            # check if parent isn't a special directive
+            if hasattr(node, 'parent'):
+                if node.parent.tagname == 'substitution_definition':
+                    # .. |ref| replace:: something
+                    return
+                elif node.parent.tagname == 'substitution_reference':
+                    # |ref|
+                    return
+                elif node.parent.tagname == 'comment':
+                    # .. COMMENT
+                    return
+                elif node.parent.tagname == 'footnote_reference':
+                    # .. [#]_
+                    # .. [*]_
+                    # rewrite it to handle autonum/sym here
+                    # close tags with departure
+                    return
+
+            if self.do_strip_text:
+                node = node.replace('\n', ' ')
+                node = node.replace('  ', ' ')
+                node = node.replace('\t', ' ')
+                node = node.replace('  ', ' ')
+                if node.startswith(' '):
+                    node = ' ' + node.lstrip(' ')
+                if node.endswith(' '):
+                    node = node.rstrip(' ') + ' '
+                if self.text.endswith(' ') and node.startswith(' '):
+                    node = node[1:]
+            self.text += node
+
+        elif cls is nodes.paragraph:
+            self.do_strip_text = True
+
+            if isinstance(node.parent, nodes.footnote):
+                if self.foot_refblock:
+                    self.text = self.foot_refblock + ' '
+                self.foot_refblock = None
+                # self.do_strip_text = False
+
+            label = RstParagraph(document=self.root)
+            if isinstance(self.current, RstEntry):
+                label.mx = 10
+            self.current.add_widget(label)
+            self.push(label)
+
+        elif cls is nodes.literal_block:
+            box = RstLiteralBlock()
+            self.current.add_widget(box)
+            self.push(box)
+
+        elif cls is nodes.emphasis:
+            self.text += '[i]'
+
+        elif cls is nodes.strong:
+            self.text += '[b]'
+
+        elif cls is nodes.literal:
+            self.text += '[font=fonts/RobotoMono-Regular.ttf]'
+
+        elif cls is nodes.block_quote:
+            box = RstBlockQuote()
+            self.current.add_widget(box)
+            self.push(box.content)
+            assert(self.text == '')
+
+        elif cls is nodes.enumerated_list:
+            box = RstList()
+            self.current.add_widget(box)
+            self.push(box)
+            self.idx_list = 0
+
+        elif cls is nodes.bullet_list:
+            box = RstList()
+            self.current.add_widget(box)
+            self.push(box)
+            self.idx_list = None
+
+        elif cls is nodes.list_item:
+            bullet = '-'
+            if self.idx_list is not None:
+                self.idx_list += 1
+                bullet = '%d.' % self.idx_list
+            bullet = self.colorize(bullet, 'bullet')
+            item = RstListItem()
+            self.current.add_widget(RstListBullet(
+                text=bullet, document=self.root))
+            self.current.add_widget(item)
+            self.push(item)
+
+        elif cls is nodes.system_message:
+            label = RstSystemMessage()
+            if self.root.show_errors:
+                self.current.add_widget(label)
+            self.push(label)
+
+        elif cls is nodes.warning:
+            label = RstWarning()
+            self.current.add_widget(label)
+            self.push(label.content)
+            assert(self.text == '')
+
+        elif cls is nodes.note:
+            label = RstNote()
+            self.current.add_widget(label)
+            self.push(label.content)
+            assert(self.text == '')
+
+        elif cls is nodes.image:
+            # docutils parser breaks path with spaces
+            # e.g. "C:/my path" -> "C:/mypath"
+            uri = node['uri']
+            align = node.get('align', 'center')
+            image_size = [
+                node.get('width'),
+                node.get('height')
+            ]
+
+            # use user's size if defined
+            def set_size(img, size):
+                img.size = [
+                    size[0] or img.width,
+                    size[1] or img.height
+                ]
+
+            if uri.startswith('/') and self.root.document_root:
+                uri = join(self.root.document_root, uri[1:])
+
+            if uri.startswith('http://') or uri.startswith('https://'):
+                image = RstAsyncImage(source=uri)
+                image.bind(on_load=lambda *a: set_size(image, image_size))
+            else:
+                image = RstImage(source=uri)
+                set_size(image, image_size)
+
+            root = AnchorLayout(
+                size_hint_y=None,
+                anchor_x=align,
+                height=image.height
+            )
+
+            image.bind(height=root.setter('height'))
+            root.add_widget(image)
+            self.current.add_widget(root)
+            # TODO:
+            # .. _img: <url>
+            # .. |img| image:: <img>
+            # |img|_ <- needs refs and on_ref_press
+
+        elif cls is nodes.definition_list:
+            lst = RstDefinitionList(document=self.root)
+            self.current.add_widget(lst)
+            self.push(lst)
+
+        elif cls is nodes.term:
+            assert(isinstance(self.current, RstDefinitionList))
+            term = RstTerm(document=self.root)
+            self.current.add_widget(term)
+            self.push(term)
+
+        elif cls is nodes.definition:
+            assert(isinstance(self.current, RstDefinitionList))
+            definition = RstDefinition(document=self.root)
+            definition.add_widget(RstDefinitionSpace(document=self.root))
+            self.current.add_widget(definition)
+            self.push(definition)
+
+        elif cls is nodes.field_list:
+            fieldlist = RstFieldList()
+            self.current.add_widget(fieldlist)
+            self.push(fieldlist)
+
+        elif cls is nodes.field_name:
+            name = RstFieldName(document=self.root)
+            self.current.add_widget(name)
+            self.push(name)
+
+        elif cls is nodes.field_body:
+            body = RstFieldBody()
+            self.current.add_widget(body)
+            self.push(body)
+
+        elif cls is nodes.table:
+            table = RstTable(cols=0)
+            self.current.add_widget(table)
+            self.push(table)
+
+        elif cls is nodes.colspec:
+            self.current.cols += 1
+
+        elif cls is nodes.entry:
+            entry = RstEntry()
+            self.current.add_widget(entry)
+            self.push(entry)
+
+        elif cls is nodes.transition:
+            self.current.add_widget(RstTransition())
+
+        elif cls is nodes.reference:
+            name = node.get('name', node.get('refuri'))
+            self.text += '[ref=%s][color=%s]' % (
+                name, self.root.colors.get(
+                    'link', self.root.colors.get('paragraph')))
+            if 'refname' in node and 'name' in node:
+                self.root.refs_assoc[node['name']] = node['refname']
+
+        elif cls is nodes.target:
+            name = None
+            if 'ids' in node:
+                name = node['ids'][0]
+            elif 'names' in node:
+                name = node['names'][0]
+            self.text += '[anchor=%s]' % name
+            self.text_have_anchor = True
+
+        elif cls is role_doc:
+            self.doc_index = len(self.text)
+
+        elif cls is role_video:
+            pass
+
+    def dispatch_departure(self, node):
+        cls = node.__class__
+        if cls is nodes.document:
+            self.pop()
+
+        elif cls is nodes.section:
+            self.section -= 1
+
+        elif cls is nodes.title:
+            assert(isinstance(self.current, RstTitle))
+            if not self.title:
+                self.title = self.text
+            self.set_text(self.current, 'title')
+            self.pop()
+
+        elif cls is nodes.Text:
+            pass
+
+        elif cls is nodes.paragraph:
+            self.do_strip_text = False
+            assert(isinstance(self.current, RstParagraph))
+            self.set_text(self.current, 'paragraph')
+            self.pop()
+
+        elif cls is nodes.literal_block:
+            assert(isinstance(self.current, RstLiteralBlock))
+            self.set_text(self.current.content, 'literal_block')
+            self.pop()
+
+        elif cls is nodes.emphasis:
+            self.text += '[/i]'
+
+        elif cls is nodes.strong:
+            self.text += '[/b]'
+
+        elif cls is nodes.literal:
+            self.text += '[/font]'
+
+        elif cls is nodes.block_quote:
+            self.pop()
+
+        elif cls is nodes.enumerated_list:
+            self.idx_list = None
+            self.pop()
+
+        elif cls is nodes.bullet_list:
+            self.pop()
+
+        elif cls is nodes.list_item:
+            self.pop()
+
+        elif cls is nodes.system_message:
+            self.pop()
+
+        elif cls is nodes.warning:
+            self.pop()
+
+        elif cls is nodes.note:
+            self.pop()
+
+        elif cls is nodes.definition_list:
+            self.pop()
+
+        elif cls is nodes.term:
+            assert(isinstance(self.current, RstTerm))
+            self.set_text(self.current, 'term')
+            self.pop()
+
+        elif cls is nodes.definition:
+            self.pop()
+
+        elif cls is nodes.field_list:
+            self.pop()
+
+        elif cls is nodes.field_name:
+            assert(isinstance(self.current, RstFieldName))
+            self.set_text(self.current, 'field_name')
+            self.pop()
+
+        elif cls is nodes.field_body:
+            self.pop()
+
+        elif cls is nodes.table:
+            self.pop()
+
+        elif cls is nodes.colspec:
+            pass
+
+        elif cls is nodes.entry:
+            self.pop()
+
+        elif cls is nodes.reference:
+            self.text += '[/color][/ref]'
+
+        elif cls is nodes.footnote:
+            self.pop()
+            self.set_text(self.current, 'link')
+
+        elif cls is nodes.footnote_reference:
+            # close opened footnote [x]
+            # self.text += '[/ref]'
+            # self.set_text(self.current, 'link')
+            self.text += '[/color][/ref]'
+            # self.text += '[/color][/ref]'
+            self.text += '&br;'
+
+        elif cls is role_doc:
+            docname = self.text[self.doc_index:]
+            rst_docname = docname
+            if rst_docname.endswith('.rst'):
+                docname = docname[:-4]
+            else:
+                rst_docname += '.rst'
+
+            # try to preload it
+            filename = self.root.resolve_path(rst_docname)
+            self.root.preload(filename)
+
+            # if exist, use the title of the first section found in the
+            # document
+            title = docname
+            if filename in self.root.toctrees:
+                toctree = self.root.toctrees[filename]
+                if len(toctree):
+                    title = toctree[0]['title']
+
+            # replace the text with a good reference
+            text = '[ref=%s]%s[/ref]' % (
+                rst_docname,
+                self.colorize(title, 'link'))
+            self.text = self.text[:self.doc_index] + text
+
+        elif cls is role_video:
+            width = node['width'] if 'width' in node.attlist() else 400
+            height = node['height'] if 'height' in node.attlist() else 300
+            uri = node['source']
+            if uri.startswith('/') and self.root.document_root:
+                uri = join(self.root.document_root, uri[1:])
+            video = RstVideoPlayer(
+                source=uri,
+                size_hint=(None, None),
+                size=(width, height))
+            anchor = AnchorLayout(size_hint_y=None, height=height + 20)
+            anchor.add_widget(video)
+            self.current.add_widget(anchor)
+
+    def set_text(self, node, parent):
+        text = self.text
+        if parent == 'term' or parent == 'field_name':
+            text = '[b]%s[/b]' % text
+        # search anchors
+        node.text = self.colorize(text, parent)
+        node.bind(on_ref_press=self.root.on_ref_press)
+        if self.text_have_anchor:
+            self.root.add_anchors(node)
+        self.text = ''
+        self.text_have_anchor = False
+
+    def colorize(self, text, name):
+        return '[color=%s]%s[/color]' % (
+            self.root.colors.get(name, self.root.colors['paragraph']),
+            text)
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    import sys
+    runTouchApp(RstDocument(source=sys.argv[1]))
diff --git a/kivy/uix/sandbox.py b/kivy/uix/sandbox.py
new file mode 100644
index 0000000..4bde781
--- /dev/null
+++ b/kivy/uix/sandbox.py
@@ -0,0 +1,198 @@
+'''
+Sandbox
+=======
+
+.. versionadded:: 1.8.0
+
+.. warning::
+
+    This is experimental and subject to change as long as this warning notice
+    is present.
+
+This is a widget that runs itself and all of its children in a Sandbox. That
+means if a child raises an Exception, it will be caught. The Sandbox
+itself runs its own Clock, Cache, etc.
+
+The SandBox widget is still experimental and required for the Kivy designer.
+When the user designs their own widget, if they do something wrong (wrong size
+value, invalid python code), it will be caught correctly without breaking
+the whole application. Because it has been designed that way, we are still
+enhancing this widget and the :mod:`kivy.context` module.
+Don't use it unless you know what you are doing.
+
+'''
+
+__all__ = ('Sandbox', )
+
+from functools import wraps
+from kivy.context import Context
+from kivy.base import ExceptionManagerBase
+from kivy.clock import Clock
+from kivy.uix.widget import Widget
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.relativelayout import RelativeLayout
+from kivy.lang import Builder
+
+
+def sandbox(f):
+    @wraps(f)
+    def _f2(self, *args, **kwargs):
+        ret = None
+        with self:
+            ret = f(self, *args, **kwargs)
+        return ret
+    return _f2
+
+
+class SandboxExceptionManager(ExceptionManagerBase):
+
+    def __init__(self, sandbox):
+        ExceptionManagerBase.__init__(self)
+        self.sandbox = sandbox
+
+    def handle_exception(self, e):
+        if not self.sandbox.on_exception(e):
+            return ExceptionManagerBase.RAISE
+        return ExceptionManagerBase.PASS
+
+
+class SandboxContent(RelativeLayout):
+    pass
+
+
+class Sandbox(FloatLayout):
+    '''Sandbox widget, used to trap all the exceptions raised by child
+    widgets.
+    '''
+
+    def __init__(self, **kwargs):
+        self._context = Context(init=True)
+        self._context['ExceptionManager'] = SandboxExceptionManager(self)
+        self._context.sandbox = self
+        self._context.push()
+        self.on_context_created()
+        self._container = None
+        super(Sandbox, self).__init__(**kwargs)
+        self._container = SandboxContent(size=self.size, pos=self.pos)
+        super(Sandbox, self).add_widget(self._container)
+        self._context.pop()
+
+        # force SandboxClock's scheduling
+        Clock.schedule_interval(self._clock_sandbox, 0)
+        Clock.schedule_once(self._clock_sandbox_draw, -1)
+        self.main_clock = object.__getattribute__(Clock, '_obj')
+
+    def __enter__(self):
+        self._context.push()
+
+    def __exit__(self, _type, value, traceback):
+        self._context.pop()
+        if _type is not None:
+            return self.on_exception(value, _traceback=traceback)
+
+    def on_context_created(self):
+        '''Override this method in order to load your kv file or do anything
+        else with the newly created context.
+        '''
+        pass
+
+    def on_exception(self, exception, _traceback=None):
+        '''Override this method in order to catch all the exceptions from
+        children.
+
+        If you return True, it will not reraise the exception.
+        If you return False, the exception will be raised to the parent.
+        '''
+        import traceback
+        traceback.print_tb(_traceback)
+        return True
+
+    on_motion = sandbox(Widget.on_motion)
+    on_touch_down = sandbox(Widget.on_touch_down)
+    on_touch_move = sandbox(Widget.on_touch_move)
+    on_touch_up = sandbox(Widget.on_touch_up)
+
+    @sandbox
+    def add_widget(self, *args, **kwargs):
+        self._container.add_widget(*args, **kwargs)
+
+    @sandbox
+    def remove_widget(self, *args, **kwargs):
+        self._container.remove_widget(*args, **kwargs)
+
+    @sandbox
+    def clear_widgets(self, *args, **kwargs):
+        self._container.clear_widgets(*args, **kwargs)
+
+    @sandbox
+    def on_size(self, *args):
+        if self._container:
+            self._container.size = self.size
+
+    @sandbox
+    def on_pos(self, *args):
+        if self._container:
+            self._container.pos = self.pos
+
+    @sandbox
+    def _clock_sandbox(self, dt):
+        # import pdb; pdb.set_trace()
+        Clock.tick()
+        Builder.sync()
+
+    @sandbox
+    def _clock_sandbox_draw(self, dt):
+        Clock.tick_draw()
+        Builder.sync()
+        self.main_clock.schedule_once(self._call_draw, 0)
+
+    def _call_draw(self, dt):
+        self.main_clock.schedule_once(self._clock_sandbox_draw, -1)
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    from kivy.uix.button import Button
+
+    class TestButton(Button):
+
+        def on_touch_up(self, touch):
+            # raise Exception('fdfdfdfdfdfdfd')
+            return super(TestButton, self).on_touch_up(touch)
+
+        def on_touch_down(self, touch):
+            # raise Exception('')
+            return super(TestButton, self).on_touch_down(touch)
+
+    s = Sandbox()
+    with s:
+        Builder.load_string('''
+<TestButton>:
+    canvas:
+        Color:
+            rgb: (.3, .2, 0) if self.state == 'normal' else (.7, .7, 0)
+        Rectangle:
+            pos: self.pos
+            size: self.size
+        Color:
+            rgb: 1, 1, 1
+        Rectangle:
+            size: self.texture_size
+            pos: self.center_x - self.texture_size[0] / 2.,\
+                 self.center_y - self.texture_size[1] / 2.
+            texture: self.texture
+
+    # invalid... for testing.
+    # on_touch_up: root.d()
+    # on_touch_down: root.f()
+    on_release: root.args()
+    # on_press: root.args()
+''')
+        b = TestButton(text='Hello World')
+        s.add_widget(b)
+
+        # this exception is within the "with" block, but will be ignored by
+        # default because the sandbox on_exception will return True
+        raise Exception('hello')
+
+    runTouchApp(s)
diff --git a/kivy/uix/scatter.py b/kivy/uix/scatter.py
new file mode 100644
index 0000000..6804131
--- /dev/null
+++ b/kivy/uix/scatter.py
@@ -0,0 +1,645 @@
+'''
+Scatter
+=======
+
+.. image:: images/scatter.gif
+    :align: right
+
+:class:`Scatter` is used to build interactive widgets that can be translated,
+rotated and scaled with two or more fingers on a multitouch system.
+
+Scatter has its own matrix transformation: the modelview matrix is changed
+before the children are drawn and the previous matrix is restored when the
+drawing is finished. That makes it possible to perform rotation, scaling and
+translation over the entire children tree without changing any widget
+properties. That specific behavior makes the scatter unique, but there are some
+advantages / constraints that you should consider:
+
+#. The children are positioned relative to the scatter similarly to a
+   :mod:`~kivy.uix.relativelayout.RelativeLayout`. So when dragging the
+   scatter, the position of the children don't change, only the position of
+   the scatter does.
+#. The scatter size has no impact on the size of its children.
+#. If you want to resize the scatter, use scale, not size (read #2). Scale
+   transforms both the scatter and its children, but does not change size.
+#. The scatter is not a layout. You must manage the size of the children
+   yourself.
+
+For touch events, the scatter converts from the parent matrix to the scatter
+matrix automatically in on_touch_down/move/up events. If you are doing things
+manually, you will need to use :meth:`~kivy.uix.widget.Widget.to_parent` and
+:meth:`~kivy.uix.widget.Widget.to_local`.
+
+Usage
+-----
+
+By default, the Scatter does not have a graphical representation: it is a
+container only. The idea is to combine the Scatter with another widget, for
+example an :class:`~kivy.uix.image.Image`::
+
+    scatter = Scatter()
+    image = Image(source='sun.jpg')
+    scatter.add_widget(image)
+
+Control Interactions
+--------------------
+
+By default, all interactions are enabled. You can selectively disable
+them using the do_rotation, do_translation and do_scale properties.
+
+Disable rotation::
+
+    scatter = Scatter(do_rotation=False)
+
+Allow only translation::
+
+    scatter = Scatter(do_rotation=False, do_scale=False)
+
+Allow only translation on x axis::
+
+    scatter = Scatter(do_rotation=False, do_scale=False,
+                      do_translation_y=False)
+
+
+Automatic Bring to Front
+------------------------
+
+If the :attr:`Scatter.auto_bring_to_front` property is True, the scatter
+widget will be removed and re-added to the parent when it is touched
+(brought to front, above all other widgets in the parent). This is useful
+when you are manipulating several scatter widgets and don't want the active
+one to be partially hidden.
+
+Scale Limitation
+----------------
+
+We are using a 32-bit matrix in double representation. That means we have
+a limit for scaling. You cannot do infinite scaling down/up with our
+implementation. Generally, you don't hit the minimum scale (because you don't
+see it on the screen), but the maximum scale is 9.99506983235e+19 (2^66).
+
+You can also limit the minimum and maximum scale allowed::
+
+    scatter = Scatter(scale_min=.5, scale_max=3.)
+
+Behavior
+--------
+
+.. versionchanged:: 1.1.0
+    If no control interactions are enabled, then the touch handler will never
+    return True.
+
+'''
+
+__all__ = ('Scatter', 'ScatterPlane')
+
+from math import radians
+from kivy.properties import BooleanProperty, AliasProperty, \
+    NumericProperty, ObjectProperty, BoundedNumericProperty
+from kivy.vector import Vector
+from kivy.uix.widget import Widget
+from kivy.graphics.transformation import Matrix
+
+
+class Scatter(Widget):
+    '''Scatter class. See module documentation for more information.
+
+    :Events:
+        `on_transform_with_touch`:
+            Fired when the scatter has been transformed by user touch
+            or multitouch, such as panning or zooming.
+        `on_bring_to_front`:
+            Fired when the scatter is brought to the front.
+
+    .. versionchanged:: 1.9.0
+        Event `on_bring_to_front` added.
+
+    .. versionchanged:: 1.8.0
+        Event `on_transform_with_touch` added.
+    '''
+
+    __events__ = ('on_transform_with_touch', 'on_bring_to_front')
+
+    auto_bring_to_front = BooleanProperty(True)
+    '''If True, the widget will be automatically pushed on the top of parent
+    widget list for drawing.
+
+    :attr:`auto_bring_to_front` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True.
+    '''
+
+    do_translation_x = BooleanProperty(True)
+    '''Allow translation on the X axis.
+
+    :attr:`do_translation_x` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    do_translation_y = BooleanProperty(True)
+    '''Allow translation on Y axis.
+
+    :attr:`do_translation_y` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    def _get_do_translation(self):
+        return (self.do_translation_x, self.do_translation_y)
+
+    def _set_do_translation(self, value):
+        if type(value) in (list, tuple):
+            self.do_translation_x, self.do_translation_y = value
+        else:
+            self.do_translation_x = self.do_translation_y = bool(value)
+
+    do_translation = AliasProperty(_get_do_translation, _set_do_translation,
+                                   bind=('do_translation_x',
+                                         'do_translation_y'),
+                                   cache=True)
+    '''Allow translation on the X or Y axis.
+
+    :attr:`do_translation` is an :class:`~kivy.properties.AliasProperty` of
+    (:attr:`do_translation_x` + :attr:`do_translation_y`)
+    '''
+
+    translation_touches = BoundedNumericProperty(1, min=1)
+    '''Determine whether translation was triggered by a single or multiple
+    touches. This only has effect when :attr:`do_translation` = True.
+
+    :attr:`translation_touches` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 1.
+
+    .. versionadded:: 1.7.0
+    '''
+
+    do_rotation = BooleanProperty(True)
+    '''Allow rotation.
+
+    :attr:`do_rotation` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    do_scale = BooleanProperty(True)
+    '''Allow scaling.
+
+    :attr:`do_scale` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    do_collide_after_children = BooleanProperty(False)
+    '''If True, the collision detection for limiting the touch inside the
+    scatter will be done after dispaching the touch to the children.
+    You can put children outside the bounding box of the scatter and still be
+    able to touch them.
+
+    :attr:`do_collide_after_children` is a
+    :class:`~kivy.properties.BooleanProperty` and defaults to False.
+
+    .. versionadded:: 1.3.0
+    '''
+
+    scale_min = NumericProperty(0.01)
+    '''Minimum scaling factor allowed.
+
+    :attr:`scale_min` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.01.
+    '''
+
+    scale_max = NumericProperty(1e20)
+    '''Maximum scaling factor allowed.
+
+    :attr:`scale_max` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1e20.
+    '''
+
+    transform = ObjectProperty(Matrix())
+    '''Transformation matrix.
+
+    :attr:`transform` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to the identity matrix.
+
+    .. note::
+
+        This matrix reflects the current state of the transformation matrix
+        but setting it directly will erase previously applied
+        transformations. To apply a transformation considering context,
+        please use the :attr:`~Scatter.apply_transform` method.
+
+    '''
+
+    transform_inv = ObjectProperty(Matrix())
+    '''Inverse of the transformation matrix.
+
+    :attr:`transform_inv` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to the identity matrix.
+    '''
+
+    def _get_bbox(self):
+        xmin, ymin = xmax, ymax = self.to_parent(0, 0)
+        for point in [(self.width, 0), (0, self.height), self.size]:
+            x, y = self.to_parent(*point)
+            if x < xmin:
+                xmin = x
+            if y < ymin:
+                ymin = y
+            if x > xmax:
+                xmax = x
+            if y > ymax:
+                ymax = y
+        return (xmin, ymin), (xmax - xmin, ymax - ymin)
+
+    bbox = AliasProperty(_get_bbox, bind=('transform', 'width', 'height'))
+    '''Bounding box of the widget in parent space::
+
+        ((x, y), (w, h))
+        # x, y = lower left corner
+
+    :attr:`bbox` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_rotation(self):
+        v1 = Vector(0, 10)
+        tp = self.to_parent
+        v2 = Vector(*tp(*self.pos)) - tp(self.x, self.y + 10)
+        return -1.0 * (v1.angle(v2) + 180) % 360
+
+    def _set_rotation(self, rotation):
+        angle_change = self.rotation - rotation
+        r = Matrix().rotate(-radians(angle_change), 0, 0, 1)
+        self.apply_transform(r, post_multiply=True,
+                             anchor=self.to_local(*self.center))
+
+    rotation = AliasProperty(_get_rotation, _set_rotation,
+                             bind=('x', 'y', 'transform'))
+    '''Rotation value of the scatter in degrees moving in a counterclockwise
+    direction.
+
+    :attr:`rotation` is an :class:`~kivy.properties.AliasProperty` and defaults
+    to 0.0.
+    '''
+
+    def _get_scale(self):
+        p1 = Vector(*self.to_parent(0, 0))
+        p2 = Vector(*self.to_parent(1, 0))
+        scale = p1.distance(p2)
+
+        # XXX float calculation are not accurate, and then, scale can be
+        # thrown again even with only the position change. So to
+        # prevent anything wrong with scale, just avoid to dispatch it
+        # if the scale "visually" didn't change. #947
+        # Remove this ugly hack when we'll be Python 3 only.
+        if hasattr(self, '_scale_p'):
+            if str(scale) == str(self._scale_p):
+                return self._scale_p
+
+        self._scale_p = scale
+        return scale
+
+    def _set_scale(self, scale):
+        rescale = scale * 1.0 / self.scale
+        self.apply_transform(Matrix().scale(rescale, rescale, rescale),
+                             post_multiply=True,
+                             anchor=self.to_local(*self.center))
+
+    scale = AliasProperty(_get_scale, _set_scale, bind=('x', 'y', 'transform'))
+    '''Scale value of the scatter.
+
+    :attr:`scale` is an :class:`~kivy.properties.AliasProperty` and defaults to
+    1.0.
+    '''
+
+    def _get_center(self):
+        return (self.bbox[0][0] + self.bbox[1][0] / 2.0,
+                self.bbox[0][1] + self.bbox[1][1] / 2.0)
+
+    def _set_center(self, center):
+        if center == self.center:
+            return False
+        t = Vector(*center) - self.center
+        trans = Matrix().translate(t.x, t.y, 0)
+        self.apply_transform(trans)
+
+    center = AliasProperty(_get_center, _set_center, bind=('bbox',))
+
+    def _get_pos(self):
+        return self.bbox[0]
+
+    def _set_pos(self, pos):
+        _pos = self.bbox[0]
+        if pos == _pos:
+            return
+        t = Vector(*pos) - _pos
+        trans = Matrix().translate(t.x, t.y, 0)
+        self.apply_transform(trans)
+
+    pos = AliasProperty(_get_pos, _set_pos, bind=('bbox',))
+
+    def _get_x(self):
+        return self.bbox[0][0]
+
+    def _set_x(self, x):
+        if x == self.bbox[0][0]:
+            return False
+        self.pos = (x, self.y)
+        return True
+
+    x = AliasProperty(_get_x, _set_x, bind=('bbox',))
+
+    def _get_y(self):
+        return self.bbox[0][1]
+
+    def _set_y(self, y):
+        if y == self.bbox[0][1]:
+            return False
+        self.pos = (self.x, y)
+        return True
+
+    y = AliasProperty(_get_y, _set_y, bind=('bbox',))
+
+    def get_right(self):
+        return self.x + self.bbox[1][0]
+
+    def set_right(self, value):
+        self.x = value - self.bbox[1][0]
+
+    right = AliasProperty(get_right, set_right, bind=('x', 'bbox'))
+
+    def get_top(self):
+        return self.y + self.bbox[1][1]
+
+    def set_top(self, value):
+        self.y = value - self.bbox[1][1]
+
+    top = AliasProperty(get_top, set_top, bind=('y', 'bbox'))
+
+    def get_center_x(self):
+        return self.x + self.bbox[1][0] / 2.
+
+    def set_center_x(self, value):
+        self.x = value - self.bbox[1][0] / 2.
+
+    center_x = AliasProperty(get_center_x, set_center_x, bind=('x', 'bbox'))
+
+    def get_center_y(self):
+        return self.y + self.bbox[1][1] / 2.
+
+    def set_center_y(self, value):
+        self.y = value - self.bbox[1][1] / 2.
+
+    center_y = AliasProperty(get_center_y, set_center_y, bind=('y', 'bbox'))
+
+    def __init__(self, **kwargs):
+        self._touches = []
+        self._last_touch_pos = {}
+        super(Scatter, self).__init__(**kwargs)
+
+    def on_transform(self, instance, value):
+        self.transform_inv = value.inverse()
+
+    def collide_point(self, x, y):
+        x, y = self.to_local(x, y)
+        return 0 <= x <= self.width and 0 <= y <= self.height
+
+    def to_parent(self, x, y, **k):
+        p = self.transform.transform_point(x, y, 0)
+        return (p[0], p[1])
+
+    def to_local(self, x, y, **k):
+        p = self.transform_inv.transform_point(x, y, 0)
+        return (p[0], p[1])
+
+    def _apply_transform(self, m, pos=None):
+        m = self.transform.multiply(m)
+        return super(Scatter, self)._apply_transform(m, (0, 0))
+
+    def apply_transform(self, trans, post_multiply=False, anchor=(0, 0)):
+        '''
+        Transforms the scatter by applying the "trans" transformation
+        matrix (on top of its current transformation state). The resultant
+        matrix can be found in the :attr:`~Scatter.transform` property.
+
+        :Parameters:
+            `trans`: :class:`~kivy.graphics.transformation.Matrix`.
+                Transformation matrix to be applied to the scatter widget.
+            `anchor`: tuple, defaults to (0, 0).
+                The point to use as the origin of the transformation
+                (uses local widget space).
+            `post_multiply`: bool, defaults to False.
+                If True, the transform matrix is post multiplied
+                (as if applied before the current transform).
+
+        Usage example::
+
+            from kivy.graphics.transformation import Matrix
+            mat = Matrix().scale(3, 3, 3)
+            scatter_instance.apply_transform(mat)
+
+        '''
+        t = Matrix().translate(anchor[0], anchor[1], 0)
+        t = t.multiply(trans)
+        t = t.multiply(Matrix().translate(-anchor[0], -anchor[1], 0))
+
+        if post_multiply:
+            self.transform = self.transform.multiply(t)
+        else:
+            self.transform = t.multiply(self.transform)
+
+    def transform_with_touch(self, touch):
+        # just do a simple one finger drag
+        changed = False
+        if len(self._touches) == self.translation_touches:
+            # _last_touch_pos has last pos in correct parent space,
+            # just like incoming touch
+            dx = (touch.x - self._last_touch_pos[touch][0]) \
+                * self.do_translation_x
+            dy = (touch.y - self._last_touch_pos[touch][1]) \
+                * self.do_translation_y
+            dx = dx / self.translation_touches
+            dy = dy / self.translation_touches
+            self.apply_transform(Matrix().translate(dx, dy, 0))
+            changed = True
+
+        if len(self._touches) == 1:
+            return changed
+
+        # we have more than one touch... list of last known pos
+        points = [Vector(self._last_touch_pos[t]) for t in self._touches
+                  if t is not touch]
+        # add current touch last
+        points.append(Vector(touch.pos))
+
+        # we only want to transform if the touch is part of the two touches
+        # farthest apart! So first we find anchor, the point to transform
+        # around as another touch farthest away from current touch's pos
+        anchor = max(points[:-1], key=lambda p: p.distance(touch.pos))
+
+        # now we find the touch farthest away from anchor, if its not the
+        # same as touch. Touch is not one of the two touches used to transform
+        farthest = max(points, key=anchor.distance)
+        if farthest is not points[-1]:
+            return changed
+
+        # ok, so we have touch, and anchor, so we can actually compute the
+        # transformation
+        old_line = Vector(*touch.ppos) - anchor
+        new_line = Vector(*touch.pos) - anchor
+        if not old_line.length():   # div by zero
+            return changed
+
+        angle = radians(new_line.angle(old_line)) * self.do_rotation
+        if angle:
+            changed = True
+        self.apply_transform(Matrix().rotate(angle, 0, 0, 1), anchor=anchor)
+
+        if self.do_scale:
+            scale = new_line.length() / old_line.length()
+            new_scale = scale * self.scale
+            if new_scale < self.scale_min:
+                scale = self.scale_min / self.scale
+            elif new_scale > self.scale_max:
+                scale = self.scale_max / self.scale
+            self.apply_transform(Matrix().scale(scale, scale, scale),
+                                 anchor=anchor)
+            changed = True
+        return changed
+
+    def _bring_to_front(self, touch):
+        # auto bring to front
+        if self.auto_bring_to_front and self.parent:
+            parent = self.parent
+            if parent.children[0] is self:
+                return
+            parent.remove_widget(self)
+            parent.add_widget(self)
+            self.dispatch('on_bring_to_front', touch)
+
+    def on_motion(self, etype, me):
+        if me.type_id in self.motion_filter and 'pos' in me.profile:
+            me.push()
+            me.apply_transform_2d(self.to_local)
+            ret = super().on_motion(etype, me)
+            me.pop()
+            return ret
+        return super().on_motion(etype, me)
+
+    def on_touch_down(self, touch):
+        x, y = touch.x, touch.y
+
+        # if the touch isn't on the widget we do nothing
+        if not self.do_collide_after_children:
+            if not self.collide_point(x, y):
+                return False
+
+        # let the child widgets handle the event if they want
+        touch.push()
+        touch.apply_transform_2d(self.to_local)
+        if super(Scatter, self).on_touch_down(touch):
+            touch.pop()
+            self._bring_to_front(touch)
+            return True
+        touch.pop()
+
+        # if our child didn't do anything, and if we don't have any active
+        # interaction control, then don't accept the touch.
+        if not self.do_translation_x and \
+                not self.do_translation_y and \
+                not self.do_rotation and \
+                not self.do_scale:
+            return False
+
+        if self.do_collide_after_children:
+            if not self.collide_point(x, y):
+                return False
+
+        if 'multitouch_sim' in touch.profile:
+            touch.multitouch_sim = True
+        # grab the touch so we get all it later move events for sure
+        self._bring_to_front(touch)
+        touch.grab(self)
+        self._touches.append(touch)
+        self._last_touch_pos[touch] = touch.pos
+
+        return True
+
+    def on_touch_move(self, touch):
+        x, y = touch.x, touch.y
+        # let the child widgets handle the event if they want
+        if self.collide_point(x, y) and not touch.grab_current == self:
+            touch.push()
+            touch.apply_transform_2d(self.to_local)
+            if super(Scatter, self).on_touch_move(touch):
+                touch.pop()
+                return True
+            touch.pop()
+
+        # rotate/scale/translate
+        if touch in self._touches and touch.grab_current == self:
+            if self.transform_with_touch(touch):
+                self.dispatch('on_transform_with_touch', touch)
+            self._last_touch_pos[touch] = touch.pos
+
+        # stop propagating if its within our bounds
+        if self.collide_point(x, y):
+            return True
+
+    def on_transform_with_touch(self, touch):
+        '''
+        Called when a touch event has transformed the scatter widget.
+        By default this does nothing, but can be overridden by derived
+        classes that need to react to transformations caused by user
+        input.
+
+        :Parameters:
+            `touch`:
+                The touch object which triggered the transformation.
+
+        .. versionadded:: 1.8.0
+        '''
+        pass
+
+    def on_bring_to_front(self, touch):
+        '''
+        Called when a touch event causes the scatter to be brought to the
+        front of the parent (only if :attr:`auto_bring_to_front` is True)
+
+        :Parameters:
+            `touch`:
+                The touch object which brought the scatter to front.
+
+        .. versionadded:: 1.9.0
+        '''
+        pass
+
+    def on_touch_up(self, touch):
+        x, y = touch.x, touch.y
+        # if the touch isn't on the widget we do nothing, just try children
+        if not touch.grab_current == self:
+            touch.push()
+            touch.apply_transform_2d(self.to_local)
+            if super(Scatter, self).on_touch_up(touch):
+                touch.pop()
+                return True
+            touch.pop()
+
+        # remove it from our saved touches
+        if touch in self._touches and touch.grab_state:
+            touch.ungrab(self)
+            del self._last_touch_pos[touch]
+            self._touches.remove(touch)
+
+        # stop propagating if its within our bounds
+        if self.collide_point(x, y):
+            return True
+
+
+class ScatterPlane(Scatter):
+    '''This is essentially an unbounded Scatter widget. It's a convenience
+       class to make it easier to handle infinite planes.
+    '''
+
+    def __init__(self, **kwargs):
+        if 'auto_bring_to_front' not in kwargs:
+            self.auto_bring_to_front = False
+        super(ScatterPlane, self).__init__(**kwargs)
+
+    def collide_point(self, x, y):
+        return True
diff --git a/kivy/uix/scatterlayout.py b/kivy/uix/scatterlayout.py
new file mode 100644
index 0000000..f1346cf
--- /dev/null
+++ b/kivy/uix/scatterlayout.py
@@ -0,0 +1,93 @@
+'''
+Scatter Layout
+===============
+
+.. versionadded:: 1.6.0
+
+This layout behaves just like a
+:class:`~kivy.uix.relativelayout.RelativeLayout`.
+When a widget is added with position = (0,0) to a :class:`ScatterLayout`,
+the child widget will also move when you change the position of the
+:class:`ScatterLayout`. The child widget's coordinates remain
+(0,0) as they are relative to the parent layout.
+
+However, since :class:`ScatterLayout` is implemented using a
+:class:`~kivy.uix.scatter.Scatter`
+widget, you can also translate, rotate and scale the layout using touches
+or clicks, just like in the case of a normal Scatter widget, and the child
+widgets will behave as expected.
+
+In contrast to a Scatter, the Layout favours 'hint' properties, such as
+size_hint, size_hint_x, size_hint_y and pos_hint.
+
+.. note::
+
+    The :class:`ScatterLayout` is implemented as a
+    :class:`~kivy.uix.floatlayout.FloatLayout`
+    inside a :class:`~kivy.uix.scatter.Scatter`.
+
+.. warning::
+
+    Since the actual :class:`ScatterLayout` is a
+    :class:`~kivy.uix.scatter.Scatter`, its
+    add_widget and remove_widget functions are overridden to add children
+    to the embedded :class:`~kivy.uix.floatlayout.FloatLayout` (accessible as
+    the `content` property of :class:`~kivy.uix.scatter.Scatter`)
+    automatically. So if you want to access the added child elements,
+    you need self.content.children instead of self.children.
+
+.. warning::
+
+    The :class:`ScatterLayout` was introduced in 1.7.0 and was called
+    :class:`~kivy.uix.relativelayout.RelativeLayout` in prior versions.
+    The :class:`~kivy.uix.relativelayout.RelativeLayout` is now an optimized
+    implementation that uses only a positional transform to avoid some of the
+    heavier calculation involved for :class:`~kivy.uix.scatter.Scatter`.
+
+'''
+
+__all__ = ('ScatterLayout', 'ScatterPlaneLayout')
+
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.scatter import Scatter, ScatterPlane
+from kivy.properties import ObjectProperty
+
+
+class ScatterLayout(Scatter):
+    '''ScatterLayout class, see module documentation for more information.
+    '''
+
+    content = ObjectProperty()
+
+    def __init__(self, **kw):
+        self.content = FloatLayout()
+        super(ScatterLayout, self).__init__(**kw)
+        if self.content.size != self.size:
+            self.content.size = self.size
+        super(ScatterLayout, self).add_widget(self.content)
+        self.fbind('size', self.update_size)
+
+    def update_size(self, instance, size):
+        self.content.size = size
+
+    def add_widget(self, *args, **kwargs):
+        self.content.add_widget(*args, **kwargs)
+
+    def remove_widget(self, *args, **kwargs):
+        self.content.remove_widget(*args, **kwargs)
+
+    def clear_widgets(self, *args, **kwargs):
+        self.content.clear_widgets(*args, **kwargs)
+
+
+class ScatterPlaneLayout(ScatterPlane):
+    '''ScatterPlaneLayout class, see module documentation for more information.
+
+    Similar to ScatterLayout, but based on ScatterPlane - so the input is not
+    bounded.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    def collide_point(self, x, y):
+        return True
diff --git a/kivy/uix/screenmanager.py b/kivy/uix/screenmanager.py
new file mode 100644
index 0000000..a3a0e2e
--- /dev/null
+++ b/kivy/uix/screenmanager.py
@@ -0,0 +1,1275 @@
+'''Screen Manager
+==============
+
+.. image:: images/screenmanager.gif
+    :align: right
+
+.. versionadded:: 1.4.0
+
+The screen manager is a widget dedicated to managing multiple screens for your
+application. The default :class:`ScreenManager` displays only one
+:class:`Screen` at a time and uses a :class:`TransitionBase` to switch from one
+Screen to another.
+
+Multiple transitions are supported based on changing the screen coordinates /
+scale or even performing fancy animation using custom shaders.
+
+Basic Usage
+-----------
+
+Let's construct a Screen Manager with 4 named screens. When you are creating
+a screen, **you absolutely need to give a name to it**::
+
+    from kivy.uix.screenmanager import ScreenManager, Screen
+
+    # Create the manager
+    sm = ScreenManager()
+
+    # Add few screens
+    for i in range(4):
+        screen = Screen(name='Title %d' % i)
+        sm.add_widget(screen)
+
+    # By default, the first screen added into the ScreenManager will be
+    # displayed. You can then change to another screen.
+
+    # Let's display the screen named 'Title 2'
+    # A transition will automatically be used.
+    sm.current = 'Title 2'
+
+The default :attr:`ScreenManager.transition` is a :class:`SlideTransition` with
+options :attr:`~SlideTransition.direction` and
+:attr:`~TransitionBase.duration`.
+
+Please note that by default, a :class:`Screen` displays nothing: it's just a
+:class:`~kivy.uix.relativelayout.RelativeLayout`. You need to use that class as
+a root widget for your own screen, the best way being to subclass.
+
+.. warning::
+    As :class:`Screen` is a :class:`~kivy.uix.relativelayout.RelativeLayout`,
+    it is important to understand the
+    :ref:`kivy-uix-relativelayout-common-pitfalls`.
+
+Here is an example with a 'Menu Screen' and a 'Settings Screen'::
+
+    from kivy.app import App
+    from kivy.lang import Builder
+    from kivy.uix.screenmanager import ScreenManager, Screen
+
+    # Create both screens. Please note the root.manager.current: this is how
+    # you can control the ScreenManager from kv. Each screen has by default a
+    # property manager that gives you the instance of the ScreenManager used.
+    Builder.load_string("""
+    <MenuScreen>:
+        BoxLayout:
+            Button:
+                text: 'Goto settings'
+                on_press: root.manager.current = 'settings'
+            Button:
+                text: 'Quit'
+
+    <SettingsScreen>:
+        BoxLayout:
+            Button:
+                text: 'My settings button'
+            Button:
+                text: 'Back to menu'
+                on_press: root.manager.current = 'menu'
+    """)
+
+    # Declare both screens
+    class MenuScreen(Screen):
+        pass
+
+    class SettingsScreen(Screen):
+        pass
+
+    class TestApp(App):
+
+        def build(self):
+            # Create the screen manager
+            sm = ScreenManager()
+            sm.add_widget(MenuScreen(name='menu'))
+            sm.add_widget(SettingsScreen(name='settings'))
+
+            return sm
+
+    if __name__ == '__main__':
+        TestApp().run()
+
+
+Changing Direction
+------------------
+
+A common use case for :class:`ScreenManager` involves using a
+:class:`SlideTransition` which slides right to the next screen
+and slides left to the previous screen. Building on the previous
+example, this can be accomplished like so::
+
+    Builder.load_string("""
+    <MenuScreen>:
+        BoxLayout:
+            Button:
+                text: 'Goto settings'
+                on_press:
+                    root.manager.transition.direction = 'left'
+                    root.manager.current = 'settings'
+            Button:
+                text: 'Quit'
+
+    <SettingsScreen>:
+        BoxLayout:
+            Button:
+                text: 'My settings button'
+            Button:
+                text: 'Back to menu'
+                on_press:
+                    root.manager.transition.direction = 'right'
+                    root.manager.current = 'menu'
+    """)
+
+
+Advanced Usage
+--------------
+
+From 1.8.0, you can now switch dynamically to a new screen, change the
+transition options and remove the previous one by using
+:meth:`~ScreenManager.switch_to`::
+
+    sm = ScreenManager()
+    screens = [Screen(name='Title {}'.format(i)) for i in range(4)]
+
+    sm.switch_to(screens[0])
+    # later
+    sm.switch_to(screens[1], direction='right')
+
+Note that this method adds the screen to the :class:`ScreenManager` instance
+and should not be used if your screens have already been added to this
+instance. To switch to a screen which is already added, you should use the
+:attr:`~ScreenManager.current` property.
+
+
+Changing transitions
+--------------------
+
+You have multiple transitions available by default, such as:
+
+- :class:`NoTransition` - switches screens instantly with no animation
+- :class:`SlideTransition` - slide the screen in/out, from any direction
+- :class:`CardTransition` - new screen slides on the previous
+  or the old one slides off the new one depending on the mode
+- :class:`SwapTransition` - implementation of the iOS swap transition
+- :class:`FadeTransition` - shader to fade the screen in/out
+- :class:`WipeTransition` - shader to wipe the screens from right to left
+- :class:`FallOutTransition` - shader where the old screen 'falls' and
+  becomes transparent, revealing the new one behind it.
+- :class:`RiseInTransition` - shader where the new screen rises from the
+  screen centre while fading from transparent to opaque.
+
+You can easily switch transitions by changing the
+:attr:`ScreenManager.transition` property::
+
+    sm = ScreenManager(transition=FadeTransition())
+
+.. note::
+
+    Currently, none of Shader based Transitions use
+    anti-aliasing. This is because they use the FBO which doesn't have
+    any logic to handle supersampling. This is a known issue and we
+    are working on a transparent implementation that will give the
+    same results as if it had been rendered on screen.
+
+    To be more concrete, if you see sharp edged text during the animation, it's
+    normal.
+
+'''
+
+__all__ = ('Screen', 'ScreenManager', 'ScreenManagerException',
+           'TransitionBase', 'ShaderTransition', 'SlideTransition',
+           'SwapTransition', 'FadeTransition', 'WipeTransition',
+           'FallOutTransition', 'RiseInTransition', 'NoTransition',
+           'CardTransition')
+
+from kivy.compat import iteritems
+from kivy.logger import Logger
+from kivy.event import EventDispatcher
+from kivy.clock import Clock
+from kivy.uix.floatlayout import FloatLayout
+from kivy.properties import (StringProperty, ObjectProperty, AliasProperty,
+                             NumericProperty, ListProperty, OptionProperty,
+                             BooleanProperty, ColorProperty)
+from kivy.animation import Animation, AnimationTransition
+from kivy.uix.relativelayout import RelativeLayout
+from kivy.lang import Builder
+from kivy.graphics import (RenderContext, Rectangle, Fbo,
+                           ClearColor, ClearBuffers, BindTexture, PushMatrix,
+                           PopMatrix, Translate, Callback, Scale)
+
+
+class ScreenManagerException(Exception):
+    '''Exception for the :class:`ScreenManager`.
+    '''
+    pass
+
+
+class Screen(RelativeLayout):
+    '''Screen is an element intended to be used with a :class:`ScreenManager`.
+    Check module documentation for more information.
+
+    :Events:
+        `on_pre_enter`: ()
+            Event fired when the screen is about to be used: the entering
+            animation is started.
+        `on_enter`: ()
+            Event fired when the screen is displayed: the entering animation is
+            complete.
+        `on_pre_leave`: ()
+            Event fired when the screen is about to be removed: the leaving
+            animation is started.
+        `on_leave`: ()
+            Event fired when the screen is removed: the leaving animation is
+            finished.
+
+    .. versionchanged:: 1.6.0
+        Events `on_pre_enter`, `on_enter`, `on_pre_leave` and `on_leave` were
+        added.
+    '''
+
+    name = StringProperty('')
+    '''
+    Name of the screen which must be unique within a :class:`ScreenManager`.
+    This is the name used for :attr:`ScreenManager.current`.
+
+    :attr:`name` is a :class:`~kivy.properties.StringProperty` and defaults to
+    ''.
+    '''
+
+    manager = ObjectProperty(None, allownone=True)
+    ''':class:`ScreenManager` object, set when the screen is added to a
+    manager.
+
+    :attr:`manager` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None, read-only.
+
+    '''
+
+    transition_progress = NumericProperty(0.)
+    '''Value that represents the completion of the current transition, if any
+    is occurring.
+
+    If a transition is in progress, whatever the mode, the value will change
+    from 0 to 1. If you want to know if it's an entering or leaving animation,
+    check the :attr:`transition_state`.
+
+    :attr:`transition_progress` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    transition_state = OptionProperty('out', options=('in', 'out'))
+    '''Value that represents the state of the transition:
+
+    - 'in' if the transition is going to show your screen
+    - 'out' if the transition is going to hide your screen
+
+    After the transition is complete, the state will retain its last value (in
+    or out).
+
+    :attr:`transition_state` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'out'.
+    '''
+
+    __events__ = ('on_pre_enter', 'on_enter', 'on_pre_leave', 'on_leave')
+
+    def on_pre_enter(self, *args):
+        pass
+
+    def on_enter(self, *args):
+        pass
+
+    def on_pre_leave(self, *args):
+        pass
+
+    def on_leave(self, *args):
+        pass
+
+    def __repr__(self):
+        return '<Screen name=%r>' % self.name
+
+
+class TransitionBase(EventDispatcher):
+    '''TransitionBase is used to animate 2 screens within the
+    :class:`ScreenManager`. This class acts as a base for other
+    implementations like the :class:`SlideTransition` and
+    :class:`SwapTransition`.
+
+    :Events:
+        `on_progress`: Transition object, progression float
+            Fired during the animation of the transition.
+        `on_complete`: Transition object
+            Fired when the transition is finished.
+    '''
+
+    screen_out = ObjectProperty()
+    '''Property that contains the screen to hide.
+    Automatically set by the :class:`ScreenManager`.
+
+    :class:`screen_out` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    screen_in = ObjectProperty()
+    '''Property that contains the screen to show.
+    Automatically set by the :class:`ScreenManager`.
+
+    :class:`screen_in` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    duration = NumericProperty(.4)
+    '''Duration in seconds of the transition.
+
+    :class:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to .4 (= 400ms).
+
+    .. versionchanged:: 1.8.0
+
+        Default duration has been changed from 700ms to 400ms.
+    '''
+
+    manager = ObjectProperty()
+    ''':class:`ScreenManager` object, set when the screen is added to a
+    manager.
+
+    :attr:`manager` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None, read-only.
+
+    '''
+
+    is_active = BooleanProperty(False)
+    '''Indicate whether the transition is currently active or not.
+
+    :attr:`is_active` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False, read-only.
+    '''
+
+    # privates
+
+    _anim = ObjectProperty(allownone=True)
+
+    __events__ = ('on_progress', 'on_complete')
+
+    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)
+
+    def stop(self):
+        '''(internal) Stops the transition. This is automatically called by the
+        :class:`ScreenManager`.
+        '''
+        if self._anim:
+            self._anim.cancel(self)
+            self.dispatch('on_complete')
+            self._anim = None
+        self.is_active = False
+
+    def add_screen(self, screen):
+        '''(internal) Used to add a screen to the :class:`ScreenManager`.
+        '''
+        self.manager.real_add_widget(screen)
+
+    def remove_screen(self, screen):
+        '''(internal) Used to remove a screen from the :class:`ScreenManager`.
+        '''
+        self.manager.real_remove_widget(screen)
+
+    def on_complete(self):
+        self.remove_screen(self.screen_out)
+
+    def on_progress(self, progression):
+        pass
+
+    def _on_progress(self, *l):
+        progress = l[-1]
+        self.screen_in.transition_progress = progress
+        self.screen_out.transition_progress = 1. - progress
+        self.dispatch('on_progress', progress)
+
+    def _on_complete(self, *l):
+        self.is_active = False
+        self.dispatch('on_complete')
+        self.screen_in.dispatch('on_enter')
+        self.screen_out.dispatch('on_leave')
+        self._anim = None
+
+
+class ShaderTransition(TransitionBase):
+    '''Transition class that uses a Shader for animating the transition between
+    2 screens. By default, this class doesn't assign any fragment/vertex
+    shader. If you want to create your own fragment shader for the transition,
+    you need to declare the header yourself and include the "t", "tex_in" and
+    "tex_out" uniform::
+
+        # Create your own transition. This shader implements a "fading"
+        # transition.
+        fs = """$HEADER
+            uniform float t;
+            uniform sampler2D tex_in;
+            uniform sampler2D tex_out;
+
+            void main(void) {
+                vec4 cin = texture2D(tex_in, tex_coord0);
+                vec4 cout = texture2D(tex_out, tex_coord0);
+                gl_FragColor = mix(cout, cin, t);
+            }
+        """
+
+        # And create your transition
+        tr = ShaderTransition(fs=fs)
+        sm = ScreenManager(transition=tr)
+
+    '''
+
+    fs = StringProperty(None)
+    '''Fragment shader to use.
+
+    :attr:`fs` is a :class:`~kivy.properties.StringProperty` and defaults to
+    None.'''
+
+    vs = StringProperty(None)
+    '''Vertex shader to use.
+
+    :attr:`vs` is a :class:`~kivy.properties.StringProperty` and defaults to
+    None.'''
+
+    clearcolor = ColorProperty([0, 0, 0, 1])
+    '''Sets the color of Fbo ClearColor.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`clearcolor` is a :class:`~kivy.properties.ColorProperty`
+    and defaults to [0, 0, 0, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    def make_screen_fbo(self, screen):
+        fbo = Fbo(size=screen.size, with_stencilbuffer=True)
+        with fbo:
+            ClearColor(*self.clearcolor)
+            ClearBuffers()
+        fbo.add(screen.canvas)
+        with fbo.before:
+            PushMatrix()
+            Translate(-screen.x, -screen.y, 0)
+        with fbo.after:
+            PopMatrix()
+        return fbo
+
+    def on_progress(self, progress):
+        self.render_ctx['t'] = progress
+
+    def on_complete(self):
+        self.render_ctx['t'] = 1.
+        super(ShaderTransition, self).on_complete()
+
+    def _remove_out_canvas(self, *args):
+        if (self.screen_out and
+                self.screen_out.canvas in self.manager.canvas.children and
+                self.screen_out not in self.manager.children):
+            self.manager.canvas.remove(self.screen_out.canvas)
+
+    def add_screen(self, screen):
+        self.screen_in.pos = self.screen_out.pos
+        self.screen_in.size = self.screen_out.size
+        self.manager.real_remove_widget(self.screen_out)
+        self.manager.canvas.add(self.screen_out.canvas)
+
+        def remove_screen_out(instr):
+            Clock.schedule_once(self._remove_out_canvas, -1)
+            self.render_ctx.remove(instr)
+
+        self.fbo_in = self.make_screen_fbo(self.screen_in)
+        self.fbo_out = self.make_screen_fbo(self.screen_out)
+        self.manager.canvas.add(self.fbo_in)
+        self.manager.canvas.add(self.fbo_out)
+
+        self.render_ctx = RenderContext(fs=self.fs, vs=self.vs,
+                                        use_parent_modelview=True,
+                                        use_parent_projection=True)
+        with self.render_ctx:
+            BindTexture(texture=self.fbo_out.texture, index=1)
+            BindTexture(texture=self.fbo_in.texture, index=2)
+            x, y = self.screen_in.pos
+            w, h = self.fbo_in.texture.size
+            Rectangle(size=(w, h), pos=(x, y),
+                      tex_coords=self.fbo_in.texture.tex_coords)
+            Callback(remove_screen_out)
+        self.render_ctx['tex_out'] = 1
+        self.render_ctx['tex_in'] = 2
+        self.manager.canvas.add(self.render_ctx)
+
+    def remove_screen(self, screen):
+        self.manager.canvas.remove(self.fbo_in)
+        self.manager.canvas.remove(self.fbo_out)
+        self.manager.canvas.remove(self.render_ctx)
+        self._remove_out_canvas()
+        self.manager.real_add_widget(self.screen_in)
+
+    def stop(self):
+        self._remove_out_canvas()
+        super(ShaderTransition, self).stop()
+
+
+class NoTransition(TransitionBase):
+    '''No transition, instantly switches to the next screen with no delay or
+    animation.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    duration = NumericProperty(0.0)
+
+    def on_complete(self):
+        self.screen_in.pos = self.manager.pos
+        self.screen_out.pos = self.manager.pos
+        super(NoTransition, self).on_complete()
+
+
+class SlideTransition(TransitionBase):
+    '''Slide Transition, can be used to show a new screen from any direction:
+    left, right, up or down.
+    '''
+
+    direction = OptionProperty('left', options=('left', 'right', 'up', 'down'))
+    '''Direction of the transition.
+
+    :attr:`direction` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'left'. Can be one of 'left', 'right', 'up' or 'down'.
+    '''
+
+    def on_progress(self, progression):
+        a = self.screen_in
+        b = self.screen_out
+        manager = self.manager
+        x, y = manager.pos
+        width, height = manager.size
+        direction = self.direction
+        al = AnimationTransition.out_quad
+        progression = al(progression)
+        if direction == 'left':
+            a.y = b.y = y
+            a.x = x + width * (1 - progression)
+            b.x = x - width * progression
+        elif direction == 'right':
+            a.y = b.y = y
+            b.x = x + width * progression
+            a.x = x - width * (1 - progression)
+        elif direction == 'down':
+            a.x = b.x = x
+            a.y = y + height * (1 - progression)
+            b.y = y - height * progression
+        elif direction == 'up':
+            a.x = b.x = x
+            b.y = y + height * progression
+            a.y = y - height * (1 - progression)
+
+    def on_complete(self):
+        self.screen_in.pos = self.manager.pos
+        self.screen_out.pos = self.manager.pos
+        super(SlideTransition, self).on_complete()
+
+
+class CardTransition(SlideTransition):
+    '''Card transition that looks similar to Android 4.x application drawer
+    interface animation.
+
+    It supports 4 directions like SlideTransition: left, right, up and down,
+    and two modes, pop and push. If push mode is activated, the previous
+    screen does not move, and the new one slides in from the given direction.
+    If the pop mode is activated, the previous screen slides out, when the new
+    screen is already on the position of the ScreenManager.
+
+    .. versionadded:: 1.10
+    '''
+
+    mode = OptionProperty('push', options=['pop', 'push'])
+    '''Indicates if the transition should push or pop
+    the screen on/off the ScreenManager.
+
+    - 'push' means the screen slides in in the given direction
+    - 'pop' means the screen slides out in the given direction
+
+    :attr:`mode` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'push'.
+    '''
+
+    def start(self, manager):
+        '''(internal) Starts the transition. This is automatically
+        called by the :class:`ScreenManager`.
+        '''
+        super(CardTransition, self).start(manager)
+        mode = self.mode
+        a = self.screen_in
+        b = self.screen_out
+        # ensure that the correct widget is "on top"
+        if mode == 'push':
+            manager.canvas.remove(a.canvas)
+            manager.canvas.add(a.canvas)
+        elif mode == 'pop':
+            manager.canvas.remove(b.canvas)
+            manager.canvas.add(b.canvas)
+
+    def on_progress(self, progression):
+        a = self.screen_in
+        b = self.screen_out
+        manager = self.manager
+        x, y = manager.pos
+        width, height = manager.size
+        direction = self.direction
+        mode = self.mode
+        al = AnimationTransition.out_quad
+        progression = al(progression)
+        if mode == 'push':
+            b.pos = x, y
+            if direction == 'left':
+                a.pos = x + width * (1 - progression), y
+            elif direction == 'right':
+                a.pos = x - width * (1 - progression), y
+            elif direction == 'down':
+                a.pos = x, y + height * (1 - progression)
+            elif direction == 'up':
+                a.pos = x, y - height * (1 - progression)
+        elif mode == 'pop':
+            a.pos = x, y
+            if direction == 'left':
+                b.pos = x - width * progression, y
+            elif direction == 'right':
+                b.pos = x + width * progression, y
+            elif direction == 'down':
+                b.pos = x, y - height * progression
+            elif direction == 'up':
+                b.pos = x, y + height * progression
+
+
+class SwapTransition(TransitionBase):
+    '''Swap transition that looks like iOS transition when a new window
+    appears on the screen.
+    '''
+    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)
+
+    def update_scale(self, screen, center):
+        self.scales[screen].origin = center
+
+    def add_screen(self, screen):
+        self.manager.real_add_widget(screen, 1)
+
+    def on_complete(self):
+        self.screen_in.pos = self.manager.pos
+        self.screen_out.pos = self.manager.pos
+        for screen in self.screen_in, self.screen_out:
+            for canvas in screen.canvas.before, screen.canvas.after:
+                canvas.remove_group('swaptransition_scale')
+        super(SwapTransition, self).on_complete()
+
+    def on_progress(self, progression):
+        a = self.screen_in
+        b = self.screen_out
+        manager = self.manager
+
+        self.scales[b].xyz = [1. - progression * 0.7 for xyz in 'xyz']
+        self.scales[a].xyz = [0.5 + progression * 0.5 for xyz in 'xyz']
+        a.center_y = b.center_y = manager.center_y
+
+        al = AnimationTransition.in_out_sine
+
+        if progression < 0.5:
+            p2 = al(progression * 2)
+            width = manager.width * 0.7
+            widthb = manager.width * 0.2
+            a.x = manager.center_x + p2 * width / 2.
+            b.center_x = manager.center_x - p2 * widthb / 2.
+        else:
+            if self.screen_in is self.manager.children[-1]:
+                self.manager.real_remove_widget(self.screen_in)
+                self.manager.real_add_widget(self.screen_in)
+            p2 = al((progression - 0.5) * 2)
+            width = manager.width * 0.85
+            widthb = manager.width * 0.2
+            a.x = manager.x + width * (1 - p2)
+            b.center_x = manager.center_x - (1 - p2) * widthb / 2.
+
+
+class WipeTransition(ShaderTransition):
+    '''Wipe transition, based on a fragment Shader.
+    '''
+
+    WIPE_TRANSITION_FS = '''$HEADER$
+    uniform float t;
+    uniform sampler2D tex_in;
+    uniform sampler2D tex_out;
+
+    void main(void) {
+        vec4 cin = texture2D(tex_in, tex_coord0);
+        vec4 cout = texture2D(tex_out, tex_coord0);
+        gl_FragColor = mix(cout, cin, clamp((-1.5 + 1.5*tex_coord0.x + 2.5*t),
+            0.0, 1.0));
+    }
+    '''
+    fs = StringProperty(WIPE_TRANSITION_FS)
+
+
+class FadeTransition(ShaderTransition):
+    '''Fade transition, based on a fragment Shader.
+    '''
+
+    FADE_TRANSITION_FS = '''$HEADER$
+    uniform float t;
+    uniform sampler2D tex_in;
+    uniform sampler2D tex_out;
+
+    void main(void) {
+        vec4 cin = vec4(texture2D(tex_in, tex_coord0.st));
+        vec4 cout = vec4(texture2D(tex_out, tex_coord0.st));
+        vec4 frag_col = vec4(t * cin) + vec4((1.0 - t) * cout);
+        gl_FragColor = frag_col;
+    }
+    '''
+    fs = StringProperty(FADE_TRANSITION_FS)
+
+
+class FallOutTransition(ShaderTransition):
+    '''Transition where the new screen 'falls' from the screen centre,
+    becoming smaller and more transparent until it disappears, and
+    revealing the new screen behind it. Mimics the popular/standard
+    Android transition.
+
+    .. versionadded:: 1.8.0
+
+    '''
+
+    duration = NumericProperty(0.15)
+    '''Duration in seconds of the transition, replacing the default of
+    :class:`TransitionBase`.
+
+    :class:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to .15 (= 150ms).
+    '''
+
+    FALLOUT_TRANSITION_FS = '''$HEADER$
+    uniform float t;
+    uniform sampler2D tex_in;
+    uniform sampler2D tex_out;
+
+    void main(void) {
+        /* quantities for position and opacity calculation */
+        float tr = 0.5*sin(t);  /* 'real' time */
+        vec2 diff = (tex_coord0.st - 0.5) * (1.0/(1.0-tr));
+        vec2 dist = diff + 0.5;
+        float max_dist = 1.0 - tr;
+
+        /* in and out colors */
+        vec4 cin = vec4(texture2D(tex_in, tex_coord0.st));
+        vec4 cout = vec4(texture2D(tex_out, dist));
+
+        /* opacities for in and out textures */
+        float oin = clamp(1.0-cos(t), 0.0, 1.0);
+        float oout = clamp(cos(t), 0.0, 1.0);
+
+        bvec2 outside_bounds = bvec2(abs(tex_coord0.s - 0.5) > 0.5*max_dist,
+                                     abs(tex_coord0.t - 0.5) > 0.5*max_dist);
+
+        vec4 frag_col;
+        if (any(outside_bounds) ){
+            frag_col = vec4(cin.x, cin.y, cin.z, 1.0);
+            }
+        else {
+            frag_col = vec4(oout*cout.x + oin*cin.x, oout*cout.y + oin*cin.y,
+                            oout*cout.z + oin*cin.z, 1.0);
+            }
+
+        gl_FragColor = frag_col;
+    }
+    '''
+
+    fs = StringProperty(FALLOUT_TRANSITION_FS)
+
+
+class RiseInTransition(ShaderTransition):
+    '''Transition where the new screen rises from the screen centre,
+    becoming larger and changing from transparent to opaque until it
+    fills the screen. Mimics the popular/standard Android transition.
+
+    .. versionadded:: 1.8.0
+    '''
+
+    duration = NumericProperty(0.2)
+    '''Duration in seconds of the transition, replacing the default of
+    :class:`TransitionBase`.
+
+    :class:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to .2 (= 200ms).
+    '''
+
+    RISEIN_TRANSITION_FS = '''$HEADER$
+    uniform float t;
+    uniform sampler2D tex_in;
+    uniform sampler2D tex_out;
+
+    void main(void) {
+        /* quantities for position and opacity calculation */
+        float tr = 0.5 - 0.5*sqrt(sin(t));  /* 'real' time */
+        vec2 diff = (tex_coord0.st - 0.5) * (1.0/(1.0-tr));
+        vec2 dist = diff + 0.5;
+        float max_dist = 1.0 - tr;
+
+        /* in and out colors */
+        vec4 cin = vec4(texture2D(tex_in, dist));
+        vec4 cout = vec4(texture2D(tex_out, tex_coord0.st));
+
+        /* opacities for in and out textures */
+        float oin = clamp(sin(2.0*t), 0.0, 1.0);
+        float oout = clamp(1.0 - sin(2.0*t), 0.0, 1.0);
+
+        bvec2 outside_bounds = bvec2(abs(tex_coord0.s - 0.5) > 0.5*max_dist,
+                                     abs(tex_coord0.t - 0.5) > 0.5*max_dist);
+
+        vec4 frag_col;
+        if (any(outside_bounds) ){
+            frag_col = vec4(cout.x, cout.y, cout.z, 1.0);
+            }
+        else {
+            frag_col = vec4(oout*cout.x + oin*cin.x, oout*cout.y + oin*cin.y,
+                            oout*cout.z + oin*cin.z, 1.0);
+            }
+
+        gl_FragColor = frag_col;
+    }
+    '''
+
+    fs = StringProperty(RISEIN_TRANSITION_FS)
+
+
+class ScreenManager(FloatLayout):
+    '''Screen manager. This is the main class that will control your
+    :class:`Screen` stack and memory.
+
+    By default, the manager will show only one screen at a time.
+    '''
+
+    current = StringProperty(None, allownone=True)
+    '''
+    Name of the screen currently shown, or the screen to show.
+
+    ::
+
+        from kivy.uix.screenmanager import ScreenManager, Screen
+
+        sm = ScreenManager()
+        sm.add_widget(Screen(name='first'))
+        sm.add_widget(Screen(name='second'))
+
+        # By default, the first added screen will be shown. If you want to
+        # show another one, just set the 'current' property.
+        sm.current = 'second'
+
+    :attr:`current` is a :class:`~kivy.properties.StringProperty` and defaults
+    to None.
+    '''
+
+    transition = ObjectProperty(baseclass=TransitionBase)
+    '''Transition object to use for animating the transition from the current
+    screen to the next one being shown.
+
+    For example, if you want to use a :class:`WipeTransition` between
+    slides::
+
+        from kivy.uix.screenmanager import ScreenManager, Screen,
+        WipeTransition
+
+        sm = ScreenManager(transition=WipeTransition())
+        sm.add_widget(Screen(name='first'))
+        sm.add_widget(Screen(name='second'))
+
+        # by default, the first added screen will be shown. If you want to
+        # show another one, just set the 'current' property.
+        sm.current = 'second'
+
+    :attr:`transition` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to a :class:`SlideTransition`.
+
+    .. versionchanged:: 1.8.0
+
+        Default transition has been changed from :class:`SwapTransition` to
+        :class:`SlideTransition`.
+    '''
+
+    screens = ListProperty()
+    '''List of all the :class:`Screen` widgets added. You should not change
+    this list manually. Use the
+    :meth:`add_widget <kivy.uix.widget.Widget.add_widget>` method instead.
+
+    :attr:`screens` is a :class:`~kivy.properties.ListProperty` and defaults to
+    [], read-only.
+    '''
+
+    current_screen = ObjectProperty(None, allownone=True)
+    '''Contains the currently displayed screen. You must not change this
+    property manually, use :attr:`current` instead.
+
+    :attr:`current_screen` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None, read-only.
+    '''
+
+    def _get_screen_names(self):
+        return [s.name for s in self.screens]
+
+    screen_names = AliasProperty(_get_screen_names, bind=('screens',))
+    '''List of the names of all the :class:`Screen` widgets added. The list
+    is read only.
+
+    :attr:`screens_names` is an :class:`~kivy.properties.AliasProperty` and
+    is read-only. It is updated if the screen list changes or the name
+    of a screen changes.
+    '''
+
+    def __init__(self, **kwargs):
+        if 'transition' not in kwargs:
+            self.transition = SlideTransition()
+        super(ScreenManager, self).__init__(**kwargs)
+        self.fbind('pos', self._update_pos)
+
+    def _screen_name_changed(self, screen, name):
+        self.property('screen_names').dispatch(self)
+        if screen == self.current_screen:
+            self.current = name
+
+    def add_widget(self, widget, *args, **kwargs):
+        '''
+        .. versionchanged:: 2.1.0
+            Renamed argument `screen` to `widget`.
+        '''
+        if not isinstance(widget, Screen):
+            raise ScreenManagerException(
+                'ScreenManager accepts only Screen widget.')
+        if widget.manager:
+            if widget.manager is self:
+                raise ScreenManagerException(
+                    'Screen already managed by this ScreenManager (are you '
+                    'calling `switch_to` when you should be setting '
+                    '`current`?)')
+            raise ScreenManagerException(
+                'Screen already managed by another ScreenManager.')
+        widget.manager = self
+        widget.bind(name=self._screen_name_changed)
+        self.screens.append(widget)
+        if self.current is None:
+            self.current = widget.name
+
+    def remove_widget(self, widget, *args, **kwargs):
+        if not isinstance(widget, Screen):
+            raise ScreenManagerException(
+                'ScreenManager uses remove_widget only for removing Screens.')
+
+        if widget not in self.screens:
+            return
+
+        if self.current_screen == widget:
+            other = next(self)
+            if widget.name == other:
+                self.current = None
+                widget.parent.real_remove_widget(widget)
+            else:
+                self.current = other
+
+        widget.manager = None
+        widget.unbind(name=self._screen_name_changed)
+        self.screens.remove(widget)
+
+    def clear_widgets(self, children=None, *args, **kwargs):
+        '''
+        .. versionchanged:: 2.1.0
+            Renamed argument `screens` to `children`.
+        '''
+        if children is None:
+            # iterate over a copy of screens, as self.remove_widget
+            # modifies self.screens in place
+            children = self.screens[:]
+        remove_widget = self.remove_widget
+        for widget in children:
+            remove_widget(widget)
+
+    def real_add_widget(self, screen, *args):
+        # ensure screen is removed from its previous parent
+        parent = screen.parent
+        if parent:
+            parent.real_remove_widget(screen)
+        super(ScreenManager, self).add_widget(screen)
+
+    def real_remove_widget(self, screen, *args):
+        super(ScreenManager, self).remove_widget(screen)
+
+    def on_current(self, instance, value):
+        if value is None:
+            self.transition.stop()
+            self.current_screen = None
+            return
+
+        screen = self.get_screen(value)
+        if screen == self.current_screen:
+            return
+
+        self.transition.stop()
+
+        previous_screen = self.current_screen
+        self.current_screen = screen
+        if previous_screen:
+            self.transition.screen_in = screen
+            self.transition.screen_out = previous_screen
+            self.transition.start(self)
+        else:
+            self.real_add_widget(screen)
+            screen.pos = self.pos
+            self.do_layout()
+            screen.dispatch('on_pre_enter')
+            screen.dispatch('on_enter')
+
+    def get_screen(self, name):
+        '''Return the screen widget associated with the name or raise a
+        :class:`ScreenManagerException` if not found.
+        '''
+        matches = [s for s in self.screens if s.name == name]
+        num_matches = len(matches)
+        if num_matches == 0:
+            raise ScreenManagerException('No Screen with name "%s".' % name)
+        if num_matches > 1:
+            Logger.warn('Multiple screens named "%s": %s' % (name, matches))
+        return matches[0]
+
+    def has_screen(self, name):
+        '''Return True if a screen with the `name` has been found.
+
+        .. versionadded:: 1.6.0
+        '''
+        return bool([s for s in self.screens if s.name == name])
+
+    def __next__(self):
+        '''Py2K backwards compatibility without six or other lib.
+        '''
+        screens = self.screens
+        if not screens:
+            return
+        try:
+            index = screens.index(self.current_screen)
+            index = (index + 1) % len(screens)
+            return screens[index].name
+        except ValueError:
+            return
+
+    def next(self):
+        '''Return the name of the next screen from the screen list.'''
+        return self.__next__()
+
+    def previous(self):
+        '''Return the name of the previous screen from the screen list.
+        '''
+        screens = self.screens
+        if not screens:
+            return
+        try:
+            index = screens.index(self.current_screen)
+            index = (index - 1) % len(screens)
+            return screens[index].name
+        except ValueError:
+            return
+
+    def switch_to(self, screen, **options):
+        '''Add a new or existing screen to the ScreenManager and switch to it.
+        The previous screen will be "switched away" from. `options` are the
+        :attr:`transition` options that will be changed before the animation
+        happens.
+
+        If no previous screens are available, the screen will be used as the
+        main one::
+
+            sm = ScreenManager()
+            sm.switch_to(screen1)
+            # later
+            sm.switch_to(screen2, direction='left')
+            # later
+            sm.switch_to(screen3, direction='right', duration=1.)
+
+        If any animation is in progress, it will be stopped and replaced by
+        this one: you should avoid this because the animation will just look
+        weird. Use either :meth:`switch_to` or :attr:`current` but not both.
+
+        The `screen` name will be changed if there is any conflict with the
+        current screen.
+
+        .. versionadded: 1.8.0
+        '''
+        assert(screen is not None)
+
+        if not isinstance(screen, Screen):
+            raise ScreenManagerException(
+                'ScreenManager accepts only Screen widget.')
+
+        # stop any transition that might be happening already
+        self.transition.stop()
+
+        # ensure the screen name will be unique
+        if screen not in self.screens:
+            if self.has_screen(screen.name):
+                screen.name = self._generate_screen_name()
+
+        # change the transition if given explicitly
+        old_transition = self.transition
+        specified_transition = options.pop("transition", None)
+        if specified_transition:
+            self.transition = specified_transition
+
+        # change the transition options
+        for key, value in iteritems(options):
+            setattr(self.transition, key, value)
+
+        # add and leave if we are set as the current screen
+        if screen.manager is not self:
+            self.add_widget(screen)
+        if self.current_screen is screen:
+            return
+
+        old_current = self.current_screen
+
+        def remove_old_screen(transition):
+            if old_current in self.children:
+                self.remove_widget(old_current)
+                self.transition = old_transition
+            transition.unbind(on_complete=remove_old_screen)
+        self.transition.bind(on_complete=remove_old_screen)
+
+        self.current = screen.name
+
+    def _generate_screen_name(self):
+        i = 0
+        while True:
+            name = '_screen{}'.format(i)
+            if not self.has_screen(name):
+                return name
+            i += 1
+
+    def _update_pos(self, instance, value):
+        for child in self.children:
+            if self.transition.is_active and \
+                (child == self.transition.screen_in or
+                 child == self.transition.screen_out):
+                continue
+            child.pos = value
+
+    def on_motion(self, etype, me):
+        if self.transition.is_active:
+            return False
+        return super().on_motion(etype, me)
+
+    def on_touch_down(self, touch):
+        if self.transition.is_active:
+            return False
+        return super(ScreenManager, self).on_touch_down(touch)
+
+    def on_touch_move(self, touch):
+        if self.transition.is_active:
+            return False
+        return super(ScreenManager, self).on_touch_move(touch)
+
+    def on_touch_up(self, touch):
+        if self.transition.is_active:
+            return False
+        return super(ScreenManager, self).on_touch_up(touch)
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+    from kivy.uix.button import Button
+    Builder.load_string('''
+<Screen>:
+    canvas:
+        Color:
+            rgb: .2, .2, .2
+        Rectangle:
+            size: self.size
+
+    GridLayout:
+        cols: 2
+        Button:
+            text: 'Hello world'
+        Button:
+            text: 'Hello world'
+        Button:
+            text: 'Hello world'
+        Button:
+            text: 'Hello world'
+''')
+
+    class TestApp(App):
+
+        def change_view(self, *l):
+            # d = ('left', 'up', 'down', 'right')
+            # di = d.index(self.sm.transition.direction)
+            # self.sm.transition.direction = d[(di + 1) % len(d)]
+            self.sm.current = next(self.sm)
+
+        def remove_screen(self, *l):
+            self.sm.remove_widget(self.sm.get_screen('test1'))
+
+        def build(self):
+            root = FloatLayout()
+            self.sm = sm = ScreenManager(transition=SwapTransition())
+
+            sm.add_widget(Screen(name='test1'))
+            sm.add_widget(Screen(name='test2'))
+
+            btn = Button(size_hint=(None, None))
+            btn.bind(on_release=self.change_view)
+
+            btn2 = Button(size_hint=(None, None), x=100)
+            btn2.bind(on_release=self.remove_screen)
+
+            root.add_widget(sm)
+            root.add_widget(btn)
+            root.add_widget(btn2)
+            return root
+
+    TestApp().run()
diff --git a/kivy/uix/scrollview.py b/kivy/uix/scrollview.py
new file mode 100644
index 0000000..efd8572
--- /dev/null
+++ b/kivy/uix/scrollview.py
@@ -0,0 +1,1284 @@
+'''
+ScrollView
+==========
+
+.. versionadded:: 1.0.4
+
+The :class:`ScrollView` widget provides a scrollable/pannable viewport that is
+clipped at the scrollview's bounding box.
+
+
+Scrolling Behavior
+------------------
+
+The ScrollView accepts only one child and applies a viewport/window to
+it according to the :attr:`~ScrollView.scroll_x` and
+:attr:`~ScrollView.scroll_y` properties. Touches are analyzed to
+determine if the user wants to scroll or control the child in some
+other manner: you cannot do both at the same time. To determine if
+interaction is a scrolling gesture, these properties are used:
+
+    - :attr:`~ScrollView.scroll_distance`: the minimum distance to travel,
+      defaults to 20 pixels.
+    - :attr:`~ScrollView.scroll_timeout`: the maximum time period, defaults
+      to 55 milliseconds.
+
+If a touch travels :attr:`~ScrollView.scroll_distance` pixels within the
+:attr:`~ScrollView.scroll_timeout` period, it is recognized as a scrolling
+gesture and translation (scroll/pan) will begin. If the timeout occurs, the
+touch down event is dispatched to the child instead (no translation).
+
+The default value for those settings can be changed in the configuration file::
+
+    [widgets]
+    scroll_timeout = 250
+    scroll_distance = 20
+
+.. versionadded:: 1.1.1
+
+    ScrollView now animates scrolling in Y when a mousewheel is used.
+
+
+Limiting to the X or Y Axis
+---------------------------
+
+By default, the ScrollView allows scrolling along both the X and Y axes. You
+can explicitly disable scrolling on an axis by setting the
+:attr:`~ScrollView.do_scroll_x` or :attr:`~ScrollView.do_scroll_y` properties
+to False.
+
+
+Managing the Content Size and Position
+--------------------------------------
+
+The ScrollView manages the position of its children similarly to a
+:class:`~kivy.uix.relativelayout.RelativeLayout` but does not use the
+:attr:`~kivy.uix.widget.Widget.size_hint`. You must
+carefully specify the :attr:`~kivy.uix.widget.Widget.size` of your content to
+get the desired scroll/pan effect.
+
+By default, the :attr:`~kivy.uix.widget.Widget.size_hint` is (1, 1), so the
+content size will fit your ScrollView
+exactly (you will have nothing to scroll). You must deactivate at least one of
+the size_hint instructions (x or y) of the child to enable scrolling.
+Setting :attr:`~kivy.uix.widget.Widget.size_hint_min` to not be None will
+also enable scrolling for that dimension when the :class:`ScrollView` is
+smaller than the minimum size.
+
+To scroll a :class:`~kivy.uix.gridlayout.GridLayout` on it's Y-axis/vertically,
+set the child's width  to that of the ScrollView (size_hint_x=1), and set
+the size_hint_y property to None::
+
+    from kivy.uix.gridlayout import GridLayout
+    from kivy.uix.button import Button
+    from kivy.uix.scrollview import ScrollView
+    from kivy.core.window import Window
+    from kivy.app import runTouchApp
+
+    layout = GridLayout(cols=1, spacing=10, size_hint_y=None)
+    # Make sure the height is such that there is something to scroll.
+    layout.bind(minimum_height=layout.setter('height'))
+    for i in range(100):
+        btn = Button(text=str(i), size_hint_y=None, height=40)
+        layout.add_widget(btn)
+    root = ScrollView(size_hint=(1, None), size=(Window.width, Window.height))
+    root.add_widget(layout)
+
+    runTouchApp(root)
+
+
+Kv Example::
+
+    ScrollView:
+        do_scroll_x: False
+        do_scroll_y: True
+
+        Label:
+            size_hint_y: None
+            height: self.texture_size[1]
+            text_size: self.width, None
+            padding: 10, 10
+            text:
+                'really some amazing text\\n' * 100
+
+Overscroll Effects
+------------------
+
+.. versionadded:: 1.7.0
+
+When scrolling would exceed the bounds of the :class:`ScrollView`, it
+uses a :class:`~kivy.effects.scroll.ScrollEffect` to handle the
+overscroll. These effects can perform actions like bouncing back,
+changing opacity, or simply preventing scrolling beyond the normal
+boundaries. Note that complex effects may perform many computations,
+which can be slow on weaker hardware.
+
+You can change what effect is being used by setting
+:attr:`~ScrollView.effect_cls` to any effect class. Current options
+include:
+
+    - :class:`~kivy.effects.scroll.ScrollEffect`: Does not allow
+      scrolling beyond the :class:`ScrollView` boundaries.
+    - :class:`~kivy.effects.dampedscroll.DampedScrollEffect`: The
+      current default. Allows the user to scroll beyond the normal
+      boundaries, but has the content spring back once the
+      touch/click is released.
+    - :class:`~kivy.effects.opacityscroll.OpacityScrollEffect`: Similar
+      to the :class:`~kivy.effect.dampedscroll.DampedScrollEffect`, but
+      also reduces opacity during overscroll.
+
+You can also create your own scroll effect by subclassing one of these,
+then pass it as the :attr:`~ScrollView.effect_cls` in the same way.
+
+Alternatively, you can set :attr:`~ScrollView.effect_x` and/or
+:attr:`~ScrollView.effect_y` to an *instance* of the effect you want to
+use. This will override the default effect set in
+:attr:`~ScrollView.effect_cls`.
+
+All the effects are located in the :mod:`kivy.effects`.
+
+'''
+
+__all__ = ('ScrollView', )
+
+from functools import partial
+from kivy.animation import Animation
+from kivy.compat import string_types
+from kivy.config import Config
+from kivy.clock import Clock
+from kivy.factory import Factory
+from kivy.uix.stencilview import StencilView
+from kivy.metrics import dp
+from kivy.effects.dampedscroll import DampedScrollEffect
+from kivy.properties import NumericProperty, BooleanProperty, AliasProperty, \
+    ObjectProperty, ListProperty, ReferenceListProperty, OptionProperty, \
+    ColorProperty
+from kivy.uix.behaviors import FocusBehavior
+
+
+# When we are generating documentation, Config doesn't exist
+_scroll_timeout = _scroll_distance = 0
+if Config:
+    _scroll_timeout = Config.getint('widgets', 'scroll_timeout')
+    _scroll_distance = '{}sp'.format(Config.getint('widgets',
+                                                   'scroll_distance'))
+
+
+class ScrollView(StencilView):
+    '''ScrollView class. See module documentation for more information.
+
+    :Events:
+        `on_scroll_start`
+            Generic event fired when scrolling starts from touch.
+        `on_scroll_move`
+            Generic event fired when scrolling move from touch.
+        `on_scroll_stop`
+            Generic event fired when scrolling stops from touch.
+
+    .. versionchanged:: 1.9.0
+        `on_scroll_start`, `on_scroll_move` and `on_scroll_stop` events are
+        now dispatched when scrolling to handle nested ScrollViews.
+
+    .. versionchanged:: 1.7.0
+        `auto_scroll`, `scroll_friction`, `scroll_moves`, `scroll_stoptime' has
+        been deprecated, use :attr:`effect_cls` instead.
+    '''
+
+    scroll_distance = NumericProperty(_scroll_distance)
+    '''Distance to move before scrolling the :class:`ScrollView`, in pixels. As
+    soon as the distance has been traveled, the :class:`ScrollView` will start
+    to scroll, and no touch event will go to children.
+    It is advisable that you base this value on the dpi of your target device's
+    screen.
+
+    :attr:`scroll_distance` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 20 (pixels), according to the default value in user
+    configuration.
+    '''
+
+    scroll_wheel_distance = NumericProperty('20sp')
+    '''Distance to move when scrolling with a mouse wheel.
+    It is advisable that you base this value on the dpi of your target device's
+    screen.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`scroll_wheel_distance` is a
+    :class:`~kivy.properties.NumericProperty` , defaults to 20 pixels.
+    '''
+
+    scroll_timeout = NumericProperty(_scroll_timeout)
+    '''Timeout allowed to trigger the :attr:`scroll_distance`, in milliseconds.
+    If the user has not moved :attr:`scroll_distance` within the timeout,
+    the scrolling will be disabled, and the touch event will go to the
+    children.
+
+    :attr:`scroll_timeout` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 55 (milliseconds) according to the default value in user
+    configuration.
+
+    .. versionchanged:: 1.5.0
+        Default value changed from 250 to 55.
+    '''
+
+    scroll_x = NumericProperty(0.)
+    '''X scrolling value, between 0 and 1. If 0, the content's left side will
+    touch the left side of the ScrollView. If 1, the content's right side will
+    touch the right side.
+
+    This property is controlled by :class:`ScrollView` only if
+    :attr:`do_scroll_x` is True.
+
+    :attr:`scroll_x` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    scroll_y = NumericProperty(1.)
+    '''Y scrolling value, between 0 and 1. If 0, the content's bottom side will
+    touch the bottom side of the ScrollView. If 1, the content's top side will
+    touch the top side.
+
+    This property is controlled by :class:`ScrollView` only if
+    :attr:`do_scroll_y` is True.
+
+    :attr:`scroll_y` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+    '''
+
+    do_scroll_x = BooleanProperty(True)
+    '''Allow scroll on X axis.
+
+    :attr:`do_scroll_x` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    do_scroll_y = BooleanProperty(True)
+    '''Allow scroll on Y axis.
+
+    :attr:`do_scroll_y` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    def _get_do_scroll(self):
+        return (self.do_scroll_x, self.do_scroll_y)
+
+    def _set_do_scroll(self, value):
+        if isinstance(value, (list, tuple)):
+            self.do_scroll_x, self.do_scroll_y = value
+        else:
+            self.do_scroll_x = self.do_scroll_y = bool(value)
+
+    do_scroll = AliasProperty(_get_do_scroll, _set_do_scroll,
+                              bind=('do_scroll_x', 'do_scroll_y'),
+                              cache=True)
+    '''Allow scroll on X or Y axis.
+
+    :attr:`do_scroll` is a :class:`~kivy.properties.AliasProperty` of
+    (:attr:`do_scroll_x` + :attr:`do_scroll_y`)
+    '''
+
+    always_overscroll = BooleanProperty(True)
+    '''Make sure user can overscroll even if there is not enough content
+    to require scrolling.
+
+    This is useful if you want to trigger some action on overscroll, but
+    there is not always enough content to trigger it.
+
+    :attr:`always_overscroll` is a
+    :class:`~kivy.properties.BooleanProperty` and defaults to `True`.
+
+    .. versionadded:: 2.0.0
+
+    The option was added and enabled by default, set to False to get the
+    previous behavior of only allowing to overscroll when there is
+    enough content to allow scrolling.
+    '''
+
+    def _get_vbar(self):
+        # must return (y, height) in %
+        # calculate the viewport size / scrollview size %
+        if self._viewport is None:
+            return 0, 1.
+        vh = self._viewport.height
+        h = self.height
+        if vh < h or vh == 0:
+            return 0, 1.
+        ph = max(0.01, h / float(vh))
+        sy = min(1.0, max(0.0, self.scroll_y))
+        py = (1. - ph) * sy
+        return (py, ph)
+
+    vbar = AliasProperty(_get_vbar,
+                         bind=('scroll_y', '_viewport', 'viewport_size',
+                               'height'),
+                         cache=True)
+    '''Return a tuple of (position, size) of the vertical scrolling bar.
+
+    .. versionadded:: 1.2.0
+
+    The position and size are normalized between 0-1, and represent a
+    proportion of the current scrollview height. This property is used
+    internally for drawing the little vertical bar when you're scrolling.
+
+    :attr:`vbar` is a :class:`~kivy.properties.AliasProperty`, readonly.
+    '''
+
+    def _get_hbar(self):
+        # must return (x, width) in %
+        # calculate the viewport size / scrollview size %
+        if self._viewport is None:
+            return 0, 1.
+        vw = self._viewport.width
+        w = self.width
+        if vw < w or vw == 0:
+            return 0, 1.
+        pw = max(0.01, w / float(vw))
+        sx = min(1.0, max(0.0, self.scroll_x))
+        px = (1. - pw) * sx
+        return (px, pw)
+
+    hbar = AliasProperty(_get_hbar,
+                         bind=('scroll_x', '_viewport', 'viewport_size',
+                               'width'),
+                         cache=True)
+    '''Return a tuple of (position, size) of the horizontal scrolling bar.
+
+    .. versionadded:: 1.2.0
+
+    The position and size are normalized between 0-1, and represent a
+    proportion of the current scrollview height. This property is used
+    internally for drawing the little horizontal bar when you're scrolling.
+
+    :attr:`hbar` is a :class:`~kivy.properties.AliasProperty`, readonly.
+    '''
+
+    bar_color = ColorProperty([.7, .7, .7, .9])
+    '''Color of horizontal / vertical scroll bar, in RGBA format.
+
+    .. versionadded:: 1.2.0
+
+    :attr:`bar_color` is a :class:`~kivy.properties.ColorProperty` and defaults
+    to [.7, .7, .7, .9].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    bar_inactive_color = ColorProperty([.7, .7, .7, .2])
+    '''Color of horizontal / vertical scroll bar (in RGBA format), when no
+    scroll is happening.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`bar_inactive_color` is a
+    :class:`~kivy.properties.ColorProperty` and defaults to [.7, .7, .7, .2].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    bar_width = NumericProperty('2dp')
+    '''Width of the horizontal / vertical scroll bar. The width is interpreted
+    as a height for the horizontal bar.
+
+    .. versionadded:: 1.2.0
+
+    :attr:`bar_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 2.
+    '''
+
+    bar_pos_x = OptionProperty('bottom', options=('top', 'bottom'))
+    '''Which side of the ScrollView the horizontal scroll bar should go
+    on. Possible values are 'top' and 'bottom'.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`bar_pos_x` is an :class:`~kivy.properties.OptionProperty`,
+    defaults to 'bottom'.
+
+    '''
+
+    bar_pos_y = OptionProperty('right', options=('left', 'right'))
+    '''Which side of the ScrollView the vertical scroll bar should go
+    on. Possible values are 'left' and 'right'.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`bar_pos_y` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'right'.
+
+    '''
+
+    bar_pos = ReferenceListProperty(bar_pos_x, bar_pos_y)
+    '''Which side of the scroll view to place each of the bars on.
+
+    :attr:`bar_pos` is a :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`bar_pos_x`, :attr:`bar_pos_y`)
+    '''
+
+    bar_margin = NumericProperty(0)
+    '''Margin between the bottom / right side of the scrollview when drawing
+    the horizontal / vertical scroll bar.
+
+    .. versionadded:: 1.2.0
+
+    :attr:`bar_margin` is a :class:`~kivy.properties.NumericProperty`, default
+    to 0
+    '''
+
+    effect_cls = ObjectProperty(DampedScrollEffect, allownone=True)
+    '''Class effect to instantiate for X and Y axis.
+
+    .. versionadded:: 1.7.0
+
+    :attr:`effect_cls` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to :class:`DampedScrollEffect`.
+
+    .. versionchanged:: 1.8.0
+        If you set a string, the :class:`~kivy.factory.Factory` will be used to
+        resolve the class.
+
+    '''
+
+    effect_x = ObjectProperty(None, allownone=True)
+    '''Effect to apply for the X axis. If None is set, an instance of
+    :attr:`effect_cls` will be created.
+
+    .. versionadded:: 1.7.0
+
+    :attr:`effect_x` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    effect_y = ObjectProperty(None, allownone=True)
+    '''Effect to apply for the Y axis. If None is set, an instance of
+    :attr:`effect_cls` will be created.
+
+    .. versionadded:: 1.7.0
+
+    :attr:`effect_y` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None, read-only.
+    '''
+
+    viewport_size = ListProperty([0, 0])
+    '''(internal) Size of the internal viewport. This is the size of your only
+    child in the scrollview.
+    '''
+
+    scroll_type = OptionProperty(['content'], options=(['content'], ['bars'],
+                                 ['bars', 'content'], ['content', 'bars']))
+    '''Sets the type of scrolling to use for the content of the scrollview.
+    Available options are: ['content'], ['bars'], ['bars', 'content'].
+
+    +---------------------+------------------------------------------------+
+    | ['content']         | Content is scrolled by dragging or swiping the |
+    |                     | content directly.                              |
+    +---------------------+------------------------------------------------+
+    | ['bars']            | Content is scrolled by dragging or swiping the |
+    |                     | scroll bars.                                   |
+    +---------------------+------------------------------------------------+
+    | ['bars', 'content'] | Content is scrolled by either of the above     |
+    |                     | methods.                                       |
+    +---------------------+------------------------------------------------+
+
+    .. versionadded:: 1.8.0
+
+    :attr:`scroll_type` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to ['content'].
+    '''
+
+    smooth_scroll_end = NumericProperty(None, allownone=True)
+    '''Whether smooth scroll end should be used when scrolling with the
+    mouse-wheel and the factor of transforming the scroll distance to
+    velocity. This option also enables velocity addition meaning if you
+    scroll more, you will scroll faster and further. The recommended value
+    is `10`. The velocity is calculated as :attr:`scroll_wheel_distance` *
+    :attr:`smooth_scroll_end`.
+
+    .. versionadded:: 1.11.0
+
+    :attr:`smooth_scroll_end` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to None.
+    '''
+
+    # private, for internal use only
+
+    _viewport = ObjectProperty(None, allownone=True)
+    _bar_color = ListProperty([0, 0, 0, 0])
+    _effect_x_start_width = None
+    _effect_y_start_height = None
+    _update_effect_bounds_ev = None
+    _bind_inactive_bar_color_ev = None
+
+    def _set_viewport_size(self, instance, value):
+        self.viewport_size = value
+
+    def on__viewport(self, instance, value):
+        if value:
+            value.bind(size=self._set_viewport_size)
+            self.viewport_size = value.size
+
+    __events__ = ('on_scroll_start', 'on_scroll_move', 'on_scroll_stop')
+
+    def __init__(self, **kwargs):
+        self._touch = None
+        self._trigger_update_from_scroll = Clock.create_trigger(
+            self.update_from_scroll, -1)
+        # create a specific canvas for the viewport
+        from kivy.graphics import PushMatrix, Translate, PopMatrix, Canvas
+        self.canvas_viewport = Canvas()
+        self.canvas = Canvas()
+        with self.canvas_viewport.before:
+            PushMatrix()
+            self.g_translate = Translate(0, 0)
+        with self.canvas_viewport.after:
+            PopMatrix()
+
+        super(ScrollView, self).__init__(**kwargs)
+
+        self.register_event_type('on_scroll_start')
+        self.register_event_type('on_scroll_move')
+        self.register_event_type('on_scroll_stop')
+
+        # now add the viewport canvas to our canvas
+        self.canvas.add(self.canvas_viewport)
+
+        effect_cls = self.effect_cls
+        if isinstance(effect_cls, string_types):
+            effect_cls = Factory.get(effect_cls)
+        if self.effect_x is None and effect_cls is not None:
+            self.effect_x = effect_cls(target_widget=self._viewport)
+        if self.effect_y is None and effect_cls is not None:
+            self.effect_y = effect_cls(target_widget=self._viewport)
+
+        trigger_update_from_scroll = self._trigger_update_from_scroll
+        update_effect_widget = self._update_effect_widget
+        update_effect_x_bounds = self._update_effect_x_bounds
+        update_effect_y_bounds = self._update_effect_y_bounds
+        fbind = self.fbind
+        fbind('width', update_effect_x_bounds)
+        fbind('height', update_effect_y_bounds)
+        fbind('viewport_size', self._update_effect_bounds)
+        fbind('_viewport', update_effect_widget)
+        fbind('scroll_x', trigger_update_from_scroll)
+        fbind('scroll_y', trigger_update_from_scroll)
+        fbind('pos', trigger_update_from_scroll)
+        fbind('size', trigger_update_from_scroll)
+
+        trigger_update_from_scroll()
+        update_effect_widget()
+        update_effect_x_bounds()
+        update_effect_y_bounds()
+
+    def on_effect_x(self, instance, value):
+        if value:
+            value.bind(scroll=self._update_effect_x)
+            value.target_widget = self._viewport
+
+    def on_effect_y(self, instance, value):
+        if value:
+            value.bind(scroll=self._update_effect_y)
+            value.target_widget = self._viewport
+
+    def on_effect_cls(self, instance, cls):
+        if isinstance(cls, string_types):
+            cls = Factory.get(cls)
+        self.effect_x = cls(target_widget=self._viewport)
+        self.effect_x.bind(scroll=self._update_effect_x)
+        self.effect_y = cls(target_widget=self._viewport)
+        self.effect_y.bind(scroll=self._update_effect_y)
+
+    def _update_effect_widget(self, *args):
+        if self.effect_x:
+            self.effect_x.target_widget = self._viewport
+        if self.effect_y:
+            self.effect_y.target_widget = self._viewport
+
+    def _update_effect_x_bounds(self, *args):
+        if not self._viewport or not self.effect_x:
+            return
+        scrollable_width = self.width - self.viewport_size[0]
+        self.effect_x.min = 0
+        self.effect_x.max = min(0, scrollable_width)
+        self.effect_x.value = scrollable_width * self.scroll_x
+
+    def _update_effect_y_bounds(self, *args):
+        if not self._viewport or not self.effect_y:
+            return
+        scrollable_height = self.height - self.viewport_size[1]
+        self.effect_y.min = 0 if scrollable_height < 0 else scrollable_height
+        self.effect_y.max = scrollable_height
+        self.effect_y.value = self.effect_y.max * self.scroll_y
+
+    def _update_effect_bounds(self, *args):
+        self._update_effect_x_bounds()
+        self._update_effect_y_bounds()
+
+    def _update_effect_x(self, *args):
+        vp = self._viewport
+        if not vp or not self.effect_x:
+            return
+
+        if self.effect_x.is_manual:
+            sw = vp.width - self._effect_x_start_width
+        else:
+            sw = vp.width - self.width
+        if sw < 1 and not (self.always_overscroll and self.do_scroll_x):
+            return
+        if sw != 0:
+            sx = self.effect_x.scroll / sw
+            self.scroll_x = -sx
+        self._trigger_update_from_scroll()
+
+    def _update_effect_y(self, *args):
+        vp = self._viewport
+        if not vp or not self.effect_y:
+            return
+        if self.effect_y.is_manual:
+            sh = vp.height - self._effect_y_start_height
+        else:
+            sh = vp.height - self.height
+
+        if sh < 1 and not (self.always_overscroll and self.do_scroll_y):
+            return
+        if sh != 0:
+            sy = self.effect_y.scroll / sh
+            self.scroll_y = -sy
+        self._trigger_update_from_scroll()
+
+    def to_local(self, x, y, **k):
+        tx, ty = self.g_translate.xy
+        return x - tx, y - ty
+
+    def to_parent(self, x, y, **k):
+        tx, ty = self.g_translate.xy
+        return x + tx, y + ty
+
+    def _apply_transform(self, m, pos=None):
+        tx, ty = self.g_translate.xy
+        m.translate(tx, ty, 0)
+        return super(ScrollView, self)._apply_transform(m, (0, 0))
+
+    def simulate_touch_down(self, touch):
+        # at this point the touch is in parent coords
+        touch.push()
+        touch.apply_transform_2d(self.to_local)
+        ret = super(ScrollView, self).on_touch_down(touch)
+        touch.pop()
+        return ret
+
+    def on_motion(self, etype, me):
+        if me.type_id in self.motion_filter and 'pos' in me.profile:
+            me.push()
+            me.apply_transform_2d(self.to_local)
+            ret = super().on_motion(etype, me)
+            me.pop()
+            return ret
+        return super().on_motion(etype, me)
+
+    def on_touch_down(self, touch):
+        if self.dispatch('on_scroll_start', touch):
+            self._touch = touch
+            touch.grab(self)
+            return True
+
+    def _touch_in_handle(self, pos, size, touch):
+        x, y = pos
+        width, height = size
+        return x <= touch.x <= x + width and y <= touch.y <= y + height
+
+    def on_scroll_start(self, touch, check_children=True):
+        if check_children:
+            touch.push()
+            touch.apply_transform_2d(self.to_local)
+            if self.dispatch_children('on_scroll_start', touch):
+                touch.pop()
+                return True
+            touch.pop()
+
+        if not self.collide_point(*touch.pos):
+            touch.ud[self._get_uid('svavoid')] = True
+            return
+        if self.disabled:
+            return True
+        if self._touch or (not (self.do_scroll_x or self.do_scroll_y)):
+            return self.simulate_touch_down(touch)
+
+        # handle mouse scrolling, only if the viewport size is bigger than the
+        # scrollview size, and if the user allowed to do it
+        vp = self._viewport
+        if not vp:
+            return True
+        scroll_type = self.scroll_type
+        ud = touch.ud
+        scroll_bar = 'bars' in scroll_type
+
+        # check if touch is in bar_x(horizontal) or bar_y(vertical)
+        # width_enable_overscroll or vp.width > self.width
+        width_scrollable = (
+            (self.always_overscroll and self.do_scroll_x)
+            or vp.width > self.width
+        )
+        height_scrollable = (
+            (self.always_overscroll and self.do_scroll_y)
+            or vp.height > self.height
+        )
+
+        d = {'bottom': touch.y - self.y - self.bar_margin,
+             'top': self.top - touch.y - self.bar_margin,
+             'left': touch.x - self.x - self.bar_margin,
+             'right': self.right - touch.x - self.bar_margin}
+
+        ud['in_bar_x'] = (scroll_bar and width_scrollable and
+                          (0 <= d[self.bar_pos_x] <= self.bar_width))
+        ud['in_bar_y'] = (scroll_bar and height_scrollable and
+                          (0 <= d[self.bar_pos_y] <= self.bar_width))
+
+        if 'button' in touch.profile and touch.button.startswith('scroll'):
+            btn = touch.button
+            m = self.scroll_wheel_distance
+            e = None
+
+            if (
+                (btn == 'scrolldown' and self.scroll_y >= 1)
+                or (btn == 'scrollup' and self.scroll_y <= 0)
+                or (btn == 'scrollleft' and self.scroll_x >= 1)
+                or (btn == 'scrollright' and self.scroll_x <= 0)
+            ):
+                return False
+
+            if (
+                self.effect_x
+                and self.do_scroll_y
+                and height_scrollable
+                and btn in ('scrolldown', 'scrollup')
+            ):
+                e = self.effect_x if ud['in_bar_x'] else self.effect_y
+
+            elif (
+                self.effect_y
+                and self.do_scroll_x
+                and width_scrollable
+                and btn in ('scrollleft', 'scrollright')
+            ):
+                e = self.effect_y if ud['in_bar_y'] else self.effect_x
+
+            if e:
+                # make sure the effect's value is synced to scroll value
+                self._update_effect_bounds()
+                if btn in ('scrolldown', 'scrollleft'):
+                    if self.smooth_scroll_end:
+                        e.velocity -= m * self.smooth_scroll_end
+                    else:
+                        if self.always_overscroll:
+                            e.value = e.value - m
+                        else:
+                            e.value = max(e.value - m, e.max)
+                        e.velocity = 0
+                elif btn in ('scrollup', 'scrollright'):
+                    if self.smooth_scroll_end:
+                        e.velocity += m * self.smooth_scroll_end
+                    else:
+                        if self.always_overscroll:
+                            e.value = e.value + m
+                        else:
+                            e.value = min(e.value + m, e.min)
+                        e.velocity = 0
+                touch.ud[self._get_uid('svavoid')] = True
+                e.trigger_velocity_update()
+            return True
+
+        in_bar = ud['in_bar_x'] or ud['in_bar_y']
+        if scroll_type == ['bars'] and not in_bar:
+            return self.simulate_touch_down(touch)
+
+        if in_bar:
+            if (ud['in_bar_y'] and not
+                    self._touch_in_handle(
+                        self._handle_y_pos, self._handle_y_size, touch)):
+                self.scroll_y = (touch.y - self.y) / self.height
+            elif (ud['in_bar_x'] and not
+                    self._touch_in_handle(
+                        self._handle_x_pos, self._handle_x_size, touch)):
+                self.scroll_x = (touch.x - self.x) / self.width
+
+        # no mouse scrolling, so the user is going to drag the scrollview with
+        # this touch.
+        self._touch = touch
+        uid = self._get_uid()
+
+        ud[uid] = {
+            'mode': 'unknown',
+            'dx': 0,
+            'dy': 0,
+            'user_stopped': in_bar,
+            'frames': Clock.frames,
+            'time': touch.time_start,
+        }
+
+        if (self.do_scroll_x and self.effect_x and not ud['in_bar_x']
+                and not ud['in_bar_y']):
+            # make sure the effect's value is synced to scroll value
+            self._update_effect_bounds()
+
+            self._effect_x_start_width = self.width
+            self.effect_x.start(touch.x)
+            self._scroll_x_mouse = self.scroll_x
+
+        if (self.do_scroll_y and self.effect_y and not ud['in_bar_x']
+                and not ud['in_bar_y']):
+            # make sure the effect's value is synced to scroll value
+            self._update_effect_bounds()
+
+            self._effect_y_start_height = self.height
+            self.effect_y.start(touch.y)
+            self._scroll_y_mouse = self.scroll_y
+
+        if not in_bar:
+            Clock.schedule_once(self._change_touch_mode,
+                                self.scroll_timeout / 1000.)
+        return True
+
+    def on_touch_move(self, touch):
+        if self._touch is not touch:
+            # don't pass on touch to children if outside the sv
+            if self.collide_point(*touch.pos):
+                # touch is in parent
+                touch.push()
+                touch.apply_transform_2d(self.to_local)
+                super(ScrollView, self).on_touch_move(touch)
+                touch.pop()
+            return self._get_uid() in touch.ud
+        if touch.grab_current is not self:
+            return True
+
+        if not any(isinstance(key, str) and key.startswith('sv.')
+                   for key in touch.ud):
+            # don't pass on touch to children if outside the sv
+            if self.collide_point(*touch.pos):
+                # touch is in window coordinates
+                touch.push()
+                touch.apply_transform_2d(self.to_local)
+                res = super(ScrollView, self).on_touch_move(touch)
+                touch.pop()
+                return res
+            return False
+
+        touch.ud['sv.handled'] = {'x': False, 'y': False}
+        if self.dispatch('on_scroll_move', touch):
+            return True
+
+    def on_scroll_move(self, touch):
+        if self._get_uid('svavoid') in touch.ud:
+            return False
+
+        touch.push()
+        touch.apply_transform_2d(self.to_local)
+        if self.dispatch_children('on_scroll_move', touch):
+            touch.pop()
+            return True
+        touch.pop()
+
+        rv = True
+
+        # By default this touch can be used to defocus currently focused
+        # widget, like any touch outside of ScrollView.
+        touch.ud['sv.can_defocus'] = True
+
+        uid = self._get_uid()
+        if uid not in touch.ud:
+            self._touch = False
+            return self.on_scroll_start(touch, False)
+        ud = touch.ud[uid]
+
+        # check if the minimum distance has been travelled
+        if ud['mode'] == 'unknown':
+            if not (self.do_scroll_x or self.do_scroll_y):
+                # touch is in parent, but _change expects window coords
+                touch.push()
+                touch.apply_transform_2d(self.to_local)
+                touch.apply_transform_2d(self.to_window)
+                self._change_touch_mode()
+                touch.pop()
+                return
+            ud['dx'] += abs(touch.dx)
+            ud['dy'] += abs(touch.dy)
+            if ((ud['dx'] > self.scroll_distance and self.do_scroll_x) or
+                    (ud['dy'] > self.scroll_distance and self.do_scroll_y)):
+                ud['mode'] = 'scroll'
+
+        if ud['mode'] == 'scroll':
+            not_in_bar = not touch.ud.get('in_bar_x', False) and \
+                not touch.ud.get('in_bar_y', False)
+
+            if not touch.ud['sv.handled']['x'] and self.do_scroll_x \
+                    and self.effect_x:
+                width = self.width
+                if touch.ud.get('in_bar_x', False):
+                    if self.hbar[1] != 1:
+                        dx = touch.dx / float(width - width * self.hbar[1])
+                        self.scroll_x = min(max(self.scroll_x + dx, 0.), 1.)
+                        self._trigger_update_from_scroll()
+                elif not_in_bar:
+                    self.effect_x.update(touch.x)
+
+                if self.scroll_x < 0 or self.scroll_x > 1:
+                    rv = False
+                else:
+                    touch.ud['sv.handled']['x'] = True
+                # Touch resulted in scroll should not defocus focused widget
+                touch.ud['sv.can_defocus'] = False
+            if not touch.ud['sv.handled']['y'] and self.do_scroll_y \
+                    and self.effect_y:
+                height = self.height
+                if touch.ud.get('in_bar_y', False) and self.vbar[1] != 1.0:
+                    dy = touch.dy / float(height - height * self.vbar[1])
+                    self.scroll_y = min(max(self.scroll_y + dy, 0.), 1.)
+                    self._trigger_update_from_scroll()
+                elif not_in_bar:
+                    self.effect_y.update(touch.y)
+
+                if self.scroll_y < 0 or self.scroll_y > 1:
+                    rv = False
+                else:
+                    touch.ud['sv.handled']['y'] = True
+                # Touch resulted in scroll should not defocus focused widget
+                touch.ud['sv.can_defocus'] = False
+            ud['dt'] = touch.time_update - ud['time']
+            ud['time'] = touch.time_update
+            ud['user_stopped'] = True
+        return rv
+
+    def on_touch_up(self, touch):
+        uid = self._get_uid('svavoid')
+        if self._touch is not touch and uid not in touch.ud:
+            # don't pass on touch to children if outside the sv
+            if self.collide_point(*touch.pos):
+                # touch is in parents
+                touch.push()
+                touch.apply_transform_2d(self.to_local)
+                if super(ScrollView, self).on_touch_up(touch):
+                    touch.pop()
+                    return True
+                touch.pop()
+            return False
+
+        if self.dispatch('on_scroll_stop', touch):
+            touch.ungrab(self)
+            if not touch.ud.get('sv.can_defocus', True):
+                # Focused widget should stay focused
+                FocusBehavior.ignored_touch.append(touch)
+            return True
+
+    def on_scroll_stop(self, touch, check_children=True):
+        self._touch = None
+
+        if check_children:
+            touch.push()
+            touch.apply_transform_2d(self.to_local)
+            if self.dispatch_children('on_scroll_stop', touch):
+                touch.pop()
+                return True
+            touch.pop()
+
+        if self._get_uid('svavoid') in touch.ud:
+            return
+        if self._get_uid() not in touch.ud:
+            return False
+
+        self._touch = None
+        uid = self._get_uid()
+        ud = touch.ud[uid]
+        not_in_bar = not touch.ud.get('in_bar_x', False) and \
+            not touch.ud.get('in_bar_y', False)
+        if self.do_scroll_x and self.effect_x and not_in_bar:
+            self.effect_x.stop(touch.x)
+        if self.do_scroll_y and self.effect_y and not_in_bar:
+            self.effect_y.stop(touch.y)
+        if ud['mode'] == 'unknown':
+            # we must do the click at least..
+            # only send the click if it was not a click to stop
+            # autoscrolling
+            if not ud['user_stopped']:
+                self.simulate_touch_down(touch)
+            Clock.schedule_once(partial(self._do_touch_up, touch), .2)
+
+        ev = self._update_effect_bounds_ev
+        if ev is None:
+            ev = self._update_effect_bounds_ev = Clock.create_trigger(
+                self._update_effect_bounds)
+        ev()
+
+        # if we do mouse scrolling, always accept it
+        if 'button' in touch.profile and touch.button.startswith('scroll'):
+            return True
+
+        return self._get_uid() in touch.ud
+
+    def scroll_to(self, widget, padding=10, animate=True):
+        '''Scrolls the viewport to ensure that the given widget is visible,
+        optionally with padding and animation. If animate is True (the
+        default), then the default animation parameters will be used.
+        Otherwise, it should be a dict containing arguments to pass to
+        :class:`~kivy.animation.Animation` constructor.
+
+        .. versionadded:: 1.9.1
+        '''
+        if not self.parent:
+            return
+
+        # if _viewport is layout and has pending operation, reschedule
+        if hasattr(self._viewport, 'do_layout'):
+            if self._viewport._trigger_layout.is_triggered:
+                Clock.schedule_once(
+                     lambda *dt: self.scroll_to(widget, padding, animate))
+                return
+
+        if isinstance(padding, (int, float)):
+            padding = (padding, padding)
+
+        pos = self.parent.to_widget(*widget.to_window(*widget.pos))
+        cor = self.parent.to_widget(*widget.to_window(widget.right,
+                                                      widget.top))
+
+        dx = dy = 0
+
+        if pos[1] < self.y:
+            dy = self.y - pos[1] + dp(padding[1])
+        elif cor[1] > self.top:
+            dy = self.top - cor[1] - dp(padding[1])
+
+        if pos[0] < self.x:
+            dx = self.x - pos[0] + dp(padding[0])
+        elif cor[0] > self.right:
+            dx = self.right - cor[0] - dp(padding[0])
+
+        dsx, dsy = self.convert_distance_to_scroll(dx, dy)
+        sxp = min(1, max(0, self.scroll_x - dsx))
+        syp = min(1, max(0, self.scroll_y - dsy))
+
+        if animate:
+            if animate is True:
+                animate = {'d': 0.2, 't': 'out_quad'}
+            Animation.stop_all(self, 'scroll_x', 'scroll_y')
+            Animation(scroll_x=sxp, scroll_y=syp, **animate).start(self)
+        else:
+            self.scroll_x = sxp
+            self.scroll_y = syp
+
+    def convert_distance_to_scroll(self, dx, dy):
+        '''Convert a distance in pixels to a scroll distance, depending on the
+        content size and the scrollview size.
+
+        The result will be a tuple of scroll distance that can be added to
+        :data:`scroll_x` and :data:`scroll_y`
+        '''
+        if not self._viewport:
+            return 0, 0
+        vp = self._viewport
+        if vp.width > self.width:
+            sw = vp.width - self.width
+            sx = dx / float(sw)
+        else:
+            sx = 0
+        if vp.height > self.height:
+            sh = vp.height - self.height
+            sy = dy / float(sh)
+        else:
+            sy = 1
+        return sx, sy
+
+    def update_from_scroll(self, *largs):
+        '''Force the reposition of the content, according to current value of
+        :attr:`scroll_x` and :attr:`scroll_y`.
+
+        This method is automatically called when one of the :attr:`scroll_x`,
+        :attr:`scroll_y`, :attr:`pos` or :attr:`size` properties change, or
+        if the size of the content changes.
+        '''
+        if not self._viewport:
+            self.g_translate.xy = self.pos
+            return
+        vp = self._viewport
+
+        # update from size_hint
+        if vp.size_hint_x is not None:
+            w = vp.size_hint_x * self.width
+            if vp.size_hint_min_x is not None:
+                w = max(w, vp.size_hint_min_x)
+            if vp.size_hint_max_x is not None:
+                w = min(w, vp.size_hint_max_x)
+            vp.width = w
+
+        if vp.size_hint_y is not None:
+            h = vp.size_hint_y * self.height
+            if vp.size_hint_min_y is not None:
+                h = max(h, vp.size_hint_min_y)
+            if vp.size_hint_max_y is not None:
+                h = min(h, vp.size_hint_max_y)
+            vp.height = h
+
+        if vp.width > self.width or self.always_overscroll:
+            sw = vp.width - self.width
+            x = self.x - self.scroll_x * sw
+        else:
+            x = self.x
+
+        if vp.height > self.height or self.always_overscroll:
+            sh = vp.height - self.height
+            y = self.y - self.scroll_y * sh
+        else:
+            y = self.top - vp.height
+
+        # from 1.8.0, we now use a matrix by default, instead of moving the
+        # widget position behind. We set it here, but it will be a no-op most
+        # of the time.
+        vp.pos = 0, 0
+        self.g_translate.xy = x, y
+
+        # New in 1.2.0, show bar when scrolling happens and (changed in 1.9.0)
+        # fade to bar_inactive_color when no scroll is happening.
+        ev = self._bind_inactive_bar_color_ev
+        if ev is None:
+            ev = self._bind_inactive_bar_color_ev = Clock.create_trigger(
+                self._bind_inactive_bar_color, .5)
+        self.funbind('bar_inactive_color', self._change_bar_color)
+        Animation.stop_all(self, '_bar_color')
+        self.fbind('bar_color', self._change_bar_color)
+        self._bar_color = self.bar_color
+        ev()
+
+    def _bind_inactive_bar_color(self, *l):
+        self.funbind('bar_color', self._change_bar_color)
+        self.fbind('bar_inactive_color', self._change_bar_color)
+        Animation(
+            _bar_color=self.bar_inactive_color,
+            d=.5, t='out_quart').start(self)
+
+    def _change_bar_color(self, inst, value):
+        self._bar_color = value
+
+    def add_widget(self, widget, *args, **kwargs):
+        if self._viewport:
+            raise Exception('ScrollView accept only one widget')
+        canvas = self.canvas
+        self.canvas = self.canvas_viewport
+        super(ScrollView, self).add_widget(widget, *args, **kwargs)
+        self.canvas = canvas
+        self._viewport = widget
+        widget.bind(size=self._trigger_update_from_scroll,
+                    size_hint_min=self._trigger_update_from_scroll)
+        self._trigger_update_from_scroll()
+
+    def remove_widget(self, widget, *args, **kwargs):
+        canvas = self.canvas
+        self.canvas = self.canvas_viewport
+        super(ScrollView, self).remove_widget(widget, *args, **kwargs)
+        self.canvas = canvas
+        if widget is self._viewport:
+            self._viewport = None
+
+    def _get_uid(self, prefix='sv'):
+        return '{0}.{1}'.format(prefix, self.uid)
+
+    def _change_touch_mode(self, *largs):
+        if not self._touch:
+            return
+        uid = self._get_uid()
+        touch = self._touch
+        if uid not in touch.ud:
+            self._touch = False
+            return
+        ud = touch.ud[uid]
+        if ud['mode'] != 'unknown' or ud['user_stopped']:
+            return
+        diff_frames = Clock.frames - ud['frames']
+
+        # in order to be able to scroll on very slow devices, let at least 3
+        # frames displayed to accumulate some velocity. And then, change the
+        # touch mode. Otherwise, we might never be able to compute velocity,
+        # and no way to scroll it. See #1464 and #1499
+        if diff_frames < 3:
+            Clock.schedule_once(self._change_touch_mode, 0)
+            return
+
+        if self.do_scroll_x and self.effect_x:
+            self.effect_x.cancel()
+        if self.do_scroll_y and self.effect_y:
+            self.effect_y.cancel()
+        # XXX the next line was in the condition. But this stop
+        # the possibility to "drag" an object out of the scrollview in the
+        # non-used direction: if you have an horizontal scrollview, a
+        # vertical gesture will not "stop" the scroll view to look for an
+        # horizontal gesture, until the timeout is done.
+        # and touch.dx + touch.dy == 0:
+        touch.ungrab(self)
+        self._touch = None
+        # touch is in window coords
+        touch.push()
+        touch.apply_transform_2d(self.to_widget)
+        touch.apply_transform_2d(self.to_parent)
+        self.simulate_touch_down(touch)
+        touch.pop()
+        return
+
+    def _do_touch_up(self, touch, *largs):
+        # touch is in window coords
+        touch.push()
+        touch.apply_transform_2d(self.to_widget)
+        super(ScrollView, self).on_touch_up(touch)
+        touch.pop()
+        # don't forget about grab event!
+        for x in touch.grab_list[:]:
+            touch.grab_list.remove(x)
+            x = x()
+            if not x:
+                continue
+            touch.grab_current = x
+            # touch is in window coords
+            touch.push()
+            touch.apply_transform_2d(self.to_widget)
+            super(ScrollView, self).on_touch_up(touch)
+            touch.pop()
+        touch.grab_current = None
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+
+    from kivy.uix.gridlayout import GridLayout
+    from kivy.uix.button import Button
+
+    class ScrollViewApp(App):
+
+        def build(self):
+            layout1 = GridLayout(cols=4, spacing=10, size_hint=(None, None))
+            layout1.bind(minimum_height=layout1.setter('height'),
+                         minimum_width=layout1.setter('width'))
+            for i in range(40):
+                btn = Button(text=str(i), size_hint=(None, None),
+                             size=(200, 100))
+                layout1.add_widget(btn)
+            scrollview1 = ScrollView(bar_width='2dp', smooth_scroll_end=10)
+            scrollview1.add_widget(layout1)
+
+            layout2 = GridLayout(cols=4, spacing=10, size_hint=(None, None))
+            layout2.bind(minimum_height=layout2.setter('height'),
+                         minimum_width=layout2.setter('width'))
+            for i in range(40):
+                btn = Button(text=str(i), size_hint=(None, None),
+                             size=(200, 100))
+                layout2.add_widget(btn)
+            scrollview2 = ScrollView(scroll_type=['bars'],
+                                     bar_width='9dp',
+                                     scroll_wheel_distance=100)
+            scrollview2.add_widget(layout2)
+
+            root = GridLayout(cols=2)
+            root.add_widget(scrollview1)
+            root.add_widget(scrollview2)
+            return root
+
+    ScrollViewApp().run()
diff --git a/kivy/uix/settings.py b/kivy/uix/settings.py
new file mode 100644
index 0000000..7a75a01
--- /dev/null
+++ b/kivy/uix/settings.py
@@ -0,0 +1,1343 @@
+'''
+Settings
+========
+
+.. versionadded:: 1.0.7
+
+This module provides a complete and extensible framework for adding a
+Settings interface to your application. By default, the interface uses
+a :class:`SettingsWithSpinner`, which consists of a
+:class:`~kivy.uix.spinner.Spinner` (top) to switch between individual
+settings panels (bottom). See :ref:`differentlayouts` for some
+alternatives.
+
+.. image:: images/settingswithspinner_kivy.jpg
+    :align: center
+
+A :class:`SettingsPanel` represents a group of configurable options. The
+:attr:`SettingsPanel.title` property is used by :class:`Settings` when a panel
+is added: it determines the name of the sidebar button. SettingsPanel controls
+a :class:`~kivy.config.ConfigParser` instance.
+
+The panel can be automatically constructed from a JSON definition file: you
+describe the settings you want and corresponding sections/keys in the
+ConfigParser instance... and you're done!
+
+Settings are also integrated into the :class:`~kivy.app.App` class. Use
+:meth:`Settings.add_kivy_panel` to configure the Kivy core settings in a panel.
+
+
+.. _settings_json:
+
+Create a panel from JSON
+------------------------
+
+To create a panel from a JSON-file, you need two things:
+
+    * a :class:`~kivy.config.ConfigParser` instance with default values
+    * a JSON file
+
+.. warning::
+
+    The :class:`kivy.config.ConfigParser` is required. You cannot use the
+    default ConfigParser from Python libraries.
+
+You must create and handle the :class:`~kivy.config.ConfigParser`
+object. SettingsPanel will read the values from the associated
+ConfigParser instance. Make sure you have set default values (using
+:attr:`~kivy.config.ConfigParser.setdefaults`) for all the sections/keys
+in your JSON file!
+
+The JSON file contains structured information to describe the available
+settings. Here is an example::
+
+    [
+        {
+            "type": "title",
+            "title": "Windows"
+        },
+        {
+            "type": "bool",
+            "title": "Fullscreen",
+            "desc": "Set the window in windowed or fullscreen",
+            "section": "graphics",
+            "key": "fullscreen"
+        }
+    ]
+
+Each element in the root list represents a setting that the user can
+configure. Only the "type" key is mandatory: an instance of the associated
+class will be created and used for the setting - other keys are assigned to
+corresponding properties of that class.
+
+    ============== =================================================
+    Type           Associated class
+    -------------- -------------------------------------------------
+    title          :class:`SettingTitle`
+    bool           :class:`SettingBoolean`
+    numeric        :class:`SettingNumeric`
+    options        :class:`SettingOptions`
+    string         :class:`SettingString`
+    path           :class:`SettingPath`
+    color          :class:`SettingColor`
+    ============== =================================================
+
+    .. versionadded:: 1.1.0
+        Added :attr:`SettingPath` type
+
+    .. versionadded:: 2.1.0
+        Added :attr:`SettingColor` type
+
+In the JSON example above, the first element is of type "title". It will create
+a new instance of :class:`SettingTitle` and apply the rest of the key-value
+pairs to the properties of that class, i.e. "title": "Windows" sets the
+:attr:`~SettingsPanel.title` property of the panel to "Windows".
+
+To load the JSON example to a :class:`Settings` instance, use the
+:meth:`Settings.add_json_panel` method. It will automatically instantiate a
+:class:`SettingsPanel` and add it to :class:`Settings`::
+
+    from kivy.config import ConfigParser
+
+    config = ConfigParser()
+    config.read('myconfig.ini')
+
+    s = Settings()
+    s.add_json_panel('My custom panel', config, 'settings_custom.json')
+    s.add_json_panel('Another panel', config, 'settings_test2.json')
+
+    # then use the s as a widget...
+
+
+.. _differentlayouts:
+
+Different panel layouts
+-----------------------
+
+A kivy :class:`~kivy.app.App` can automatically create and display a
+:class:`Settings` instance. See the :attr:`~kivy.app.App.settings_cls`
+documentation for details on how to choose which settings class to
+display.
+
+Several pre-built settings widgets are available. All except
+:class:`SettingsWithNoMenu` include close buttons triggering the
+on_close event.
+
+- :class:`Settings`: Displays settings with a sidebar at the left to
+  switch between json panels.
+
+- :class:`SettingsWithSidebar`: A trivial subclass of
+  :class:`Settings`.
+
+- :class:`SettingsWithSpinner`: Displays settings with a spinner at
+  the top, which can be used to switch between json panels. Uses
+  :class:`InterfaceWithSpinner` as the
+  :attr:`~Settings.interface_cls`. This is the default behavior from
+  Kivy 1.8.0.
+
+- :class:`SettingsWithTabbedPanel`: Displays json panels as individual
+  tabs in a :class:`~kivy.uix.tabbedpanel.TabbedPanel`. Uses
+  :class:`InterfaceWithTabbedPanel` as the :attr:`~Settings.interface_cls`.
+
+- :class:`SettingsWithNoMenu`: Displays a single json panel, with no
+  way to switch to other panels and no close button. This makes it
+  impossible for the user to exit unless
+  :meth:`~kivy.app.App.close_settings` is overridden with a different
+  close trigger! Uses :class:`InterfaceWithNoMenu` as the
+  :attr:`~Settings.interface_cls`.
+
+You can construct your own settings panels with any layout you choose
+by setting :attr:`Settings.interface_cls`. This should be a widget
+that displays a json settings panel with some way to switch between
+panels. An instance will be automatically created by :class:`Settings`.
+
+Interface widgets may be anything you like, but *must* have a method
+add_panel that receives newly created json settings panels for the
+interface to display. See the documentation for
+:class:`InterfaceWithSidebar` for more information. They may
+optionally dispatch an on_close event, for instance if a close button
+is clicked. This event is used by :class:`Settings` to trigger its own
+on_close event.
+
+For a complete, working example, please see
+:file:`kivy/examples/settings/main.py`.
+
+'''
+
+__all__ = ('Settings', 'SettingsPanel', 'SettingItem', 'SettingString',
+           'SettingPath', 'SettingBoolean', 'SettingNumeric', 'SettingOptions',
+           'SettingTitle', 'SettingsWithSidebar', 'SettingsWithSpinner',
+           'SettingsWithTabbedPanel', 'SettingsWithNoMenu',
+           'InterfaceWithSidebar', 'ContentPanel', 'MenuSidebar')
+
+import json
+import os
+import kivy.utils as utils
+from kivy.factory import Factory
+from kivy.metrics import dp
+from kivy.config import ConfigParser
+from kivy.animation import Animation
+from kivy.compat import string_types, text_type
+from kivy.core.window import Window
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.tabbedpanel import TabbedPanelHeader
+from kivy.uix.button import Button
+from kivy.uix.filechooser import FileChooserListView
+from kivy.uix.colorpicker import ColorPicker
+from kivy.uix.scrollview import ScrollView
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.label import Label
+from kivy.uix.popup import Popup
+from kivy.uix.textinput import TextInput
+from kivy.uix.togglebutton import ToggleButton
+from kivy.uix.widget import Widget
+from kivy.properties import ObjectProperty, StringProperty, ListProperty, \
+    BooleanProperty, NumericProperty, DictProperty
+
+
+class SettingSpacer(Widget):
+    # Internal class, not documented.
+    pass
+
+
+class SettingItem(FloatLayout):
+    '''Base class for individual settings (within a panel). This class cannot
+    be used directly; it is used for implementing the other setting classes.
+    It builds a row with a title/description (left) and a setting control
+    (right).
+
+    Look at :class:`SettingBoolean`, :class:`SettingNumeric` and
+    :class:`SettingOptions` for usage examples.
+
+    :Events:
+        `on_release`
+            Fired when the item is touched and then released.
+
+    '''
+
+    title = StringProperty('<No title set>')
+    '''Title of the setting, defaults to '<No title set>'.
+
+    :attr:`title` is a :class:`~kivy.properties.StringProperty` and defaults
+    to '<No title set>'.
+    '''
+
+    desc = StringProperty(None, allownone=True)
+    '''Description of the setting, rendered on the line below the title.
+
+    :attr:`desc` is a :class:`~kivy.properties.StringProperty` and defaults to
+    None.
+    '''
+
+    disabled = BooleanProperty(False)
+    '''Indicate if this setting is disabled. If True, all touches on the
+    setting item will be discarded.
+
+    :attr:`disabled` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    section = StringProperty(None)
+    '''Section of the token inside the :class:`~kivy.config.ConfigParser`
+    instance.
+
+    :attr:`section` is a :class:`~kivy.properties.StringProperty` and defaults
+    to None.
+    '''
+
+    key = StringProperty(None)
+    '''Key of the token inside the :attr:`section` in the
+    :class:`~kivy.config.ConfigParser` instance.
+
+    :attr:`key` is a :class:`~kivy.properties.StringProperty` and defaults to
+    None.
+    '''
+
+    value = ObjectProperty(None)
+    '''Value of the token according to the :class:`~kivy.config.ConfigParser`
+    instance. Any change to this value will trigger a
+    :meth:`Settings.on_config_change` event.
+
+    :attr:`value` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    panel = ObjectProperty(None)
+    '''(internal) Reference to the SettingsPanel for this setting. You don't
+    need to use it.
+
+    :attr:`panel` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    content = ObjectProperty(None)
+    '''(internal) Reference to the widget that contains the real setting.
+    As soon as the content object is set, any further call to add_widget will
+    call the content.add_widget. This is automatically set.
+
+    :attr:`content` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    selected_alpha = NumericProperty(0)
+    '''(internal) Float value from 0 to 1, used to animate the background when
+    the user touches the item.
+
+    :attr:`selected_alpha` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    __events__ = ('on_release', )
+
+    def __init__(self, **kwargs):
+        super(SettingItem, self).__init__(**kwargs)
+        self.value = self.panel.get_value(self.section, self.key)
+
+    def add_widget(self, *args, **kwargs):
+        if self.content is None:
+            return super(SettingItem, self).add_widget(*args, **kwargs)
+        return self.content.add_widget(*args, **kwargs)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return
+        if self.disabled:
+            return
+        touch.grab(self)
+        self.selected_alpha = 1
+        return super(SettingItem, self).on_touch_down(touch)
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is self:
+            touch.ungrab(self)
+            self.dispatch('on_release')
+            Animation(selected_alpha=0, d=.25, t='out_quad').start(self)
+            return True
+        return super(SettingItem, self).on_touch_up(touch)
+
+    def on_release(self):
+        pass
+
+    def on_value(self, instance, value):
+        if not self.section or not self.key:
+            return
+        # get current value in config
+        panel = self.panel
+        if not isinstance(value, string_types):
+            value = str(value)
+        panel.set_value(self.section, self.key, value)
+
+
+class SettingBoolean(SettingItem):
+    '''Implementation of a boolean setting on top of a :class:`SettingItem`.
+    It is visualized with a :class:`~kivy.uix.switch.Switch` widget.
+    By default, 0 and 1 are used for values: you can change them by setting
+    :attr:`values`.
+    '''
+
+    values = ListProperty(['0', '1'])
+    '''Values used to represent the state of the setting. If you want to use
+    "yes" and "no" in your ConfigParser instance::
+
+        SettingBoolean(..., values=['no', 'yes'])
+
+    .. warning::
+
+        You need a minimum of two values, the index 0 will be used as False,
+        and index 1 as True
+
+    :attr:`values` is a :class:`~kivy.properties.ListProperty` and defaults to
+    ['0', '1']
+    '''
+
+
+class SettingString(SettingItem):
+    '''Implementation of a string setting on top of a :class:`SettingItem`.
+    It is visualized with a :class:`~kivy.uix.label.Label` widget that, when
+    clicked, will open a :class:`~kivy.uix.popup.Popup` with a
+    :class:`~kivy.uix.textinput.Textinput` so the user can enter a custom
+    value.
+    '''
+
+    popup = ObjectProperty(None, allownone=True)
+    '''(internal) Used to store the current popup when it's shown.
+
+    :attr:`popup` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    textinput = ObjectProperty(None)
+    '''(internal) Used to store the current textinput from the popup and
+    to listen for changes.
+
+    :attr:`textinput` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    def on_panel(self, instance, value):
+        if value is None:
+            return
+        self.fbind('on_release', self._create_popup)
+
+    def _dismiss(self, *largs):
+        if self.textinput:
+            self.textinput.focus = False
+        if self.popup:
+            self.popup.dismiss()
+        self.popup = None
+
+    def _validate(self, instance):
+        self._dismiss()
+        value = self.textinput.text.strip()
+        self.value = value
+
+    def _create_popup(self, instance):
+        # create popup layout
+        content = BoxLayout(orientation='vertical', spacing='5dp')
+        popup_width = min(0.95 * Window.width, dp(500))
+        self.popup = popup = Popup(
+            title=self.title, content=content, size_hint=(None, None),
+            size=(popup_width, '250dp'))
+
+        # create the textinput used for numeric input
+        self.textinput = textinput = TextInput(
+            text=self.value, font_size='24sp', multiline=False,
+            size_hint_y=None, height='42sp')
+        textinput.bind(on_text_validate=self._validate)
+        self.textinput = textinput
+
+        # construct the content, widget are used as a spacer
+        content.add_widget(Widget())
+        content.add_widget(textinput)
+        content.add_widget(Widget())
+        content.add_widget(SettingSpacer())
+
+        # 2 buttons are created for accept or cancel the current value
+        btnlayout = BoxLayout(size_hint_y=None, height='50dp', spacing='5dp')
+        btn = Button(text='Ok')
+        btn.bind(on_release=self._validate)
+        btnlayout.add_widget(btn)
+        btn = Button(text='Cancel')
+        btn.bind(on_release=self._dismiss)
+        btnlayout.add_widget(btn)
+        content.add_widget(btnlayout)
+
+        # all done, open the popup !
+        popup.open()
+
+
+class SettingPath(SettingItem):
+    '''Implementation of a Path setting on top of a :class:`SettingItem`.
+    It is visualized with a :class:`~kivy.uix.label.Label` widget that, when
+    clicked, will open a :class:`~kivy.uix.popup.Popup` with a
+    :class:`~kivy.uix.filechooser.FileChooserListView` so the user can enter
+    a custom value.
+
+    .. versionadded:: 1.1.0
+    '''
+
+    popup = ObjectProperty(None, allownone=True)
+    '''(internal) Used to store the current popup when it is shown.
+
+    :attr:`popup` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    textinput = ObjectProperty(None)
+    '''(internal) Used to store the current textinput from the popup and
+    to listen for changes.
+
+    :attr:`textinput` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    show_hidden = BooleanProperty(False)
+    '''Whether to show 'hidden' filenames. What that means is
+    operating-system-dependent.
+
+    :attr:`show_hidden` is an :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    dirselect = BooleanProperty(True)
+    '''Whether to allow selection of directories.
+
+    :attr:`dirselect` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    def on_panel(self, instance, value):
+        if value is None:
+            return
+        self.fbind('on_release', self._create_popup)
+
+    def _dismiss(self, *largs):
+        if self.textinput:
+            self.textinput.focus = False
+        if self.popup:
+            self.popup.dismiss()
+        self.popup = None
+
+    def _validate(self, instance):
+        self._dismiss()
+        value = self.textinput.selection
+
+        if not value:
+            return
+
+        self.value = os.path.realpath(value[0])
+
+    def _create_popup(self, instance):
+        # create popup layout
+        content = BoxLayout(orientation='vertical', spacing=5)
+        popup_width = min(0.95 * Window.width, dp(500))
+        self.popup = popup = Popup(
+            title=self.title, content=content, size_hint=(None, 0.9),
+            width=popup_width)
+
+        # create the filechooser
+        initial_path = self.value or os.getcwd()
+        self.textinput = textinput = FileChooserListView(
+            path=initial_path, size_hint=(1, 1),
+            dirselect=self.dirselect, show_hidden=self.show_hidden)
+        textinput.bind(on_path=self._validate)
+
+        # construct the content
+        content.add_widget(textinput)
+        content.add_widget(SettingSpacer())
+
+        # 2 buttons are created for accept or cancel the current value
+        btnlayout = BoxLayout(size_hint_y=None, height='50dp', spacing='5dp')
+        btn = Button(text='Ok')
+        btn.bind(on_release=self._validate)
+        btnlayout.add_widget(btn)
+        btn = Button(text='Cancel')
+        btn.bind(on_release=self._dismiss)
+        btnlayout.add_widget(btn)
+        content.add_widget(btnlayout)
+
+        # all done, open the popup !
+        popup.open()
+
+
+class SettingColor(SettingItem):
+    '''Implementation of a color setting on top of a :class:`SettingItem`.
+    It is visualized with a :class:`~kivy.uix.label.Label` widget and a
+    colored canvas rectangle that, when clicked, will open a
+    :class:`~kivy.uix.popup.Popup` with a
+    :class:`~kivy.uix.colorpicker.ColorPicker` so the user can choose a color.
+
+    .. versionadded:: 2.0.1
+    '''
+
+    popup = ObjectProperty(None, allownone=True)
+    '''(internal) Used to store the current popup when it's shown.
+
+    :attr:`popup` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    def on_panel(self, instance, value):
+        if value is None:
+            return
+        self.bind(on_release=self._create_popup)
+
+    def _dismiss(self, *largs):
+        if self.popup:
+            self.popup.dismiss()
+        self.popup = None
+
+    def _validate(self, instance):
+        self._dismiss()
+        value = utils.get_hex_from_color(self.colorpicker.color)
+        self.value = value
+
+    def _create_popup(self, instance):
+        # create popup layout
+        content = BoxLayout(orientation='vertical', spacing='5dp')
+        popup_width = min(0.95 * Window.width, dp(500))
+        self.popup = popup = Popup(
+            title=self.title, content=content, size_hint=(None, 0.9),
+            width=popup_width)
+
+        self.colorpicker = colorpicker = \
+            ColorPicker(color=utils.get_color_from_hex(self.value))
+        colorpicker.bind(on_color=self._validate)
+
+        self.colorpicker = colorpicker
+        content.add_widget(colorpicker)
+        content.add_widget(SettingSpacer())
+
+        # 2 buttons are created for accept or cancel the current value
+        btnlayout = BoxLayout(size_hint_y=None, height='50dp', spacing='5dp')
+        btn = Button(text='Ok')
+        btn.bind(on_release=self._validate)
+        btnlayout.add_widget(btn)
+        btn = Button(text='Cancel')
+        btn.bind(on_release=self._dismiss)
+        btnlayout.add_widget(btn)
+        content.add_widget(btnlayout)
+
+        # all done, open the popup !
+        popup.open()
+
+
+class SettingNumeric(SettingString):
+    '''Implementation of a numeric setting on top of a :class:`SettingString`.
+    It is visualized with a :class:`~kivy.uix.label.Label` widget that, when
+    clicked, will open a :class:`~kivy.uix.popup.Popup` with a
+    :class:`~kivy.uix.textinput.Textinput` so the user can enter a custom
+    value.
+    '''
+
+    def _validate(self, instance):
+        # we know the type just by checking if there is a '.' in the original
+        # value
+        is_float = '.' in str(self.value)
+        self._dismiss()
+        try:
+            if is_float:
+                self.value = text_type(float(self.textinput.text))
+            else:
+                self.value = text_type(int(self.textinput.text))
+        except ValueError:
+            return
+
+
+class SettingOptions(SettingItem):
+    '''Implementation of an option list on top of a :class:`SettingItem`.
+    It is visualized with a :class:`~kivy.uix.label.Label` widget that, when
+    clicked, will open a :class:`~kivy.uix.popup.Popup` with a
+    list of options from which the user can select.
+    '''
+
+    options = ListProperty([])
+    '''List of all availables options. This must be a list of "string" items.
+    Otherwise, it will crash. :)
+
+    :attr:`options` is a :class:`~kivy.properties.ListProperty` and defaults
+    to [].
+    '''
+
+    popup = ObjectProperty(None, allownone=True)
+    '''(internal) Used to store the current popup when it is shown.
+
+    :attr:`popup` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    def on_panel(self, instance, value):
+        if value is None:
+            return
+        self.fbind('on_release', self._create_popup)
+
+    def _set_option(self, instance):
+        self.value = instance.text
+        self.popup.dismiss()
+
+    def _create_popup(self, instance):
+        # create the popup
+        content = BoxLayout(orientation='vertical', spacing='5dp')
+        popup_width = min(0.95 * Window.width, dp(500))
+        self.popup = popup = Popup(
+            content=content, title=self.title, size_hint=(None, None),
+            size=(popup_width, '400dp'))
+        popup.height = len(self.options) * dp(55) + dp(150)
+
+        # add all the options
+        content.add_widget(Widget(size_hint_y=None, height=1))
+        uid = str(self.uid)
+        for option in self.options:
+            state = 'down' if option == self.value else 'normal'
+            btn = ToggleButton(text=option, state=state, group=uid)
+            btn.bind(on_release=self._set_option)
+            content.add_widget(btn)
+
+        # finally, add a cancel button to return on the previous panel
+        content.add_widget(SettingSpacer())
+        btn = Button(text='Cancel', size_hint_y=None, height=dp(50))
+        btn.bind(on_release=popup.dismiss)
+        content.add_widget(btn)
+
+        # and open the popup !
+        popup.open()
+
+
+class SettingTitle(Label):
+    '''A simple title label, used to organize the settings in sections.
+    '''
+
+    title = Label.text
+
+    panel = ObjectProperty(None)
+
+
+class SettingsPanel(GridLayout):
+    '''This class is used to construct panel settings, for use with a
+    :class:`Settings` instance or subclass.
+    '''
+
+    title = StringProperty('Default title')
+    '''Title of the panel. The title will be reused by the :class:`Settings` in
+    the sidebar.
+    '''
+
+    config = ObjectProperty(None, allownone=True)
+    '''A :class:`kivy.config.ConfigParser` instance. See module documentation
+    for more information.
+    '''
+
+    settings = ObjectProperty(None)
+    '''A :class:`Settings` instance that will be used to fire the
+    `on_config_change` event.
+    '''
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault('cols', 1)
+        super(SettingsPanel, self).__init__(**kwargs)
+
+    def on_config(self, instance, value):
+        if value is None:
+            return
+        if not isinstance(value, ConfigParser):
+            raise Exception('Invalid config object, you must use a'
+                            'kivy.config.ConfigParser, not another one !')
+
+    def get_value(self, section, key):
+        '''Return the value of the section/key from the :attr:`config`
+        ConfigParser instance. This function is used by :class:`SettingItem` to
+        get the value for a given section/key.
+
+        If you don't want to use a ConfigParser instance, you might want to
+        override this function.
+        '''
+        config = self.config
+        if not config:
+            return
+        return config.get(section, key)
+
+    def set_value(self, section, key, value):
+        current = self.get_value(section, key)
+        if current == value:
+            return
+        config = self.config
+        if config:
+            config.set(section, key, value)
+            config.write()
+        settings = self.settings
+        if settings:
+            settings.dispatch('on_config_change',
+                              config, section, key, value)
+
+
+class InterfaceWithSidebar(BoxLayout):
+    '''The default Settings interface class. It displays a sidebar menu
+    with names of available settings panels, which may be used to switch
+    which one is currently displayed.
+
+    See :meth:`~InterfaceWithSidebar.add_panel` for information on the
+    method you must implement if creating your own interface.
+
+    This class also dispatches an event 'on_close', which is triggered
+    when the sidebar menu's close button is released. If creating your
+    own interface widget, it should also dispatch such an event which
+    will automatically be caught by :class:`Settings` and used to
+    trigger its own 'on_close' event.
+
+    '''
+
+    menu = ObjectProperty()
+    '''(internal) A reference to the sidebar menu widget.
+
+    :attr:`menu` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    content = ObjectProperty()
+    '''(internal) A reference to the panel display widget (a
+    :class:`ContentPanel`).
+
+    :attr:`content` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+
+    '''
+
+    __events__ = ('on_close', )
+
+    def __init__(self, *args, **kwargs):
+        super(InterfaceWithSidebar, self).__init__(*args, **kwargs)
+        self.menu.close_button.bind(
+            on_release=lambda j: self.dispatch('on_close'))
+
+    def add_panel(self, panel, name, uid):
+        '''This method is used by Settings to add new panels for possible
+        display. Any replacement for ContentPanel *must* implement
+        this method.
+
+        :Parameters:
+            `panel`: :class:`SettingsPanel`
+                It should be stored and the interface should provide a way to
+                switch between panels.
+            `name`:
+                The name of the panel as a string. It may be used to represent
+                the panel but isn't necessarily unique.
+            `uid`:
+                A unique int identifying the panel. It should be used to
+                identify and switch between panels.
+
+        '''
+        self.menu.add_item(name, uid)
+        self.content.add_panel(panel, name, uid)
+
+    def on_close(self, *args):
+        pass
+
+
+class InterfaceWithSpinner(BoxLayout):
+    '''A settings interface that displays a spinner at the top for
+    switching between panels.
+
+    The workings of this class are considered internal and are not
+    documented. See :meth:`InterfaceWithSidebar` for
+    information on implementing your own interface class.
+
+    '''
+
+    __events__ = ('on_close', )
+
+    menu = ObjectProperty()
+    '''(internal) A reference to the sidebar menu widget.
+
+    :attr:`menu` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    content = ObjectProperty()
+    '''(internal) A reference to the panel display widget (a
+    :class:`ContentPanel`).
+
+    :attr:`menu` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+
+    '''
+
+    def __init__(self, *args, **kwargs):
+        super(InterfaceWithSpinner, self).__init__(*args, **kwargs)
+        self.menu.close_button.bind(
+            on_release=lambda j: self.dispatch('on_close'))
+
+    def add_panel(self, panel, name, uid):
+        '''This method is used by Settings to add new panels for possible
+        display. Any replacement for ContentPanel *must* implement
+        this method.
+
+        :Parameters:
+            `panel`: :class:`SettingsPanel`
+                It should be stored and the interface should provide a way to
+                switch between panels.
+            `name`:
+                The name of the panel as a string. It may be used to represent
+                the panel but may not be unique.
+            `uid`:
+                A unique int identifying the panel. It should be used to
+                identify and switch between panels.
+
+        '''
+        self.content.add_panel(panel, name, uid)
+        self.menu.add_item(name, uid)
+
+    def on_close(self, *args):
+        pass
+
+
+class ContentPanel(ScrollView):
+    '''A class for displaying settings panels. It displays a single
+    settings panel at a time, taking up the full size and shape of the
+    ContentPanel. It is used by :class:`InterfaceWithSidebar` and
+    :class:`InterfaceWithSpinner` to display settings.
+
+    '''
+
+    panels = DictProperty({})
+    '''(internal) Stores a dictionary mapping settings panels to their uids.
+
+    :attr:`panels` is a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+
+    '''
+
+    container = ObjectProperty()
+    '''(internal) A reference to the GridLayout that contains the
+    settings panel.
+
+    :attr:`container` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+
+    '''
+
+    current_panel = ObjectProperty(None)
+    '''(internal) A reference to the current settings panel.
+
+    :attr:`current_panel` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+
+    '''
+
+    current_uid = NumericProperty(0)
+    '''(internal) A reference to the uid of the current settings panel.
+
+    :attr:`current_uid` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to 0.
+
+    '''
+
+    def add_panel(self, panel, name, uid):
+        '''This method is used by Settings to add new panels for possible
+        display. Any replacement for ContentPanel *must* implement
+        this method.
+
+        :Parameters:
+            `panel`: :class:`SettingsPanel`
+                It should be stored and displayed when requested.
+            `name`:
+                The name of the panel as a string. It may be used to represent
+                the panel.
+            `uid`:
+                A unique int identifying the panel. It should be stored and
+                used to identify panels when switching.
+
+        '''
+        self.panels[uid] = panel
+        if not self.current_uid:
+            self.current_uid = uid
+
+    def on_current_uid(self, *args):
+        '''The uid of the currently displayed panel. Changing this will
+        automatically change the displayed panel.
+
+        :Parameters:
+            `uid`:
+                A panel uid. It should be used to retrieve and display
+                a settings panel that has previously been added with
+                :meth:`add_panel`.
+
+        '''
+        uid = self.current_uid
+        if uid in self.panels:
+            if self.current_panel is not None:
+                self.remove_widget(self.current_panel)
+            new_panel = self.panels[uid]
+            self.add_widget(new_panel)
+            self.current_panel = new_panel
+            return True
+        return False  # New uid doesn't exist
+
+    def add_widget(self, *args, **kwargs):
+        if self.container is None:
+            super(ContentPanel, self).add_widget(*args, **kwargs)
+        else:
+            self.container.add_widget(*args, **kwargs)
+
+    def remove_widget(self, *args, **kwargs):
+        self.container.remove_widget(*args, **kwargs)
+
+
+class Settings(BoxLayout):
+
+    '''Settings UI. Check module documentation for more information on how
+    to use this class.
+
+    :Events:
+        `on_config_change`: ConfigParser instance, section, key, value
+            Fired when the section's key-value pair of a ConfigParser changes.
+
+            .. warning:
+
+                value will be str/unicode type, regardless of the setting
+                type (numeric, boolean, etc)
+        `on_close`
+            Fired by the default panel when the Close button is pressed.
+
+        '''
+
+    interface = ObjectProperty(None)
+    '''(internal) Reference to the widget that will contain, organise and
+    display the panel configuration panel widgets.
+
+    :attr:`interface` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+
+    '''
+
+    interface_cls = ObjectProperty(InterfaceWithSidebar)
+    '''The widget class that will be used to display the graphical
+    interface for the settings panel. By default, it displays one Settings
+    panel at a time with a sidebar to switch between them.
+
+    :attr:`interface_cls` is an
+    :class:`~kivy.properties.ObjectProperty` and defaults to
+    :class:`InterfaceWithSidebar`.
+
+    .. versionchanged:: 1.8.0
+        If you set a string, the :class:`~kivy.factory.Factory` will be used to
+        resolve the class.
+
+    '''
+
+    __events__ = ('on_close', 'on_config_change')
+
+    def __init__(self, *args, **kargs):
+        self._types = {}
+        super(Settings, self).__init__(*args, **kargs)
+        self.add_interface()
+        self.register_type('string', SettingString)
+        self.register_type('bool', SettingBoolean)
+        self.register_type('numeric', SettingNumeric)
+        self.register_type('options', SettingOptions)
+        self.register_type('title', SettingTitle)
+        self.register_type('path', SettingPath)
+        self.register_type('color', SettingColor)
+
+    def on_touch_down(self, touch):
+        if self.collide_point(*touch.pos):
+            super(Settings, self).on_touch_down(touch)
+            return True
+
+    def register_type(self, tp, cls):
+        '''Register a new type that can be used in the JSON definition.
+        '''
+        self._types[tp] = cls
+
+    def on_close(self, *args):
+        pass
+
+    def add_interface(self):
+        '''(Internal) creates an instance of :attr:`Settings.interface_cls`,
+        and sets it to :attr:`~Settings.interface`. When json panels are
+        created, they will be added to this interface which will display them
+        to the user.
+        '''
+        cls = self.interface_cls
+        if isinstance(cls, string_types):
+            cls = Factory.get(cls)
+        interface = cls()
+        self.interface = interface
+        self.add_widget(interface)
+        self.interface.bind(on_close=lambda j: self.dispatch('on_close'))
+
+    def on_config_change(self, config, section, key, value):
+        pass
+
+    def add_json_panel(self, title, config, filename=None, data=None):
+        '''Create and add a new :class:`SettingsPanel` using the configuration
+        `config` with the JSON definition `filename`. If `filename` is not set,
+        then the JSON definition is read from the `data` parameter instead.
+
+        Check the :ref:`settings_json` section in the documentation for more
+        information about JSON format and the usage of this function.
+        '''
+        panel = self.create_json_panel(title, config, filename, data)
+        uid = panel.uid
+        if self.interface is not None:
+            self.interface.add_panel(panel, title, uid)
+
+    def create_json_panel(self, title, config, filename=None, data=None):
+        '''Create new :class:`SettingsPanel`.
+
+        .. versionadded:: 1.5.0
+
+        Check the documentation of :meth:`add_json_panel` for more information.
+        '''
+        if filename is None and data is None:
+            raise Exception('You must specify either the filename or data')
+        if filename is not None:
+            with open(filename, 'r') as fd:
+                data = json.loads(fd.read())
+        else:
+            data = json.loads(data)
+        if type(data) != list:
+            raise ValueError('The first element must be a list')
+        panel = SettingsPanel(title=title, settings=self, config=config)
+
+        for setting in data:
+            # determine the type and the class to use
+            if 'type' not in setting:
+                raise ValueError('One setting are missing the "type" element')
+            ttype = setting['type']
+            cls = self._types.get(ttype)
+            if cls is None:
+                raise ValueError(
+                    'No class registered to handle the <%s> type' %
+                    setting['type'])
+
+            # create a instance of the class, without the type attribute
+            del setting['type']
+            str_settings = {}
+            for key, item in setting.items():
+                str_settings[str(key)] = item
+
+            instance = cls(panel=panel, **str_settings)
+
+            # instance created, add to the panel
+            panel.add_widget(instance)
+
+        return panel
+
+    def add_kivy_panel(self):
+        '''Add a panel for configuring Kivy. This panel acts directly on the
+        kivy configuration. Feel free to include or exclude it in your
+        configuration.
+
+        See :meth:`~kivy.app.App.use_kivy_settings` for information on
+        enabling/disabling the automatic kivy panel.
+
+        '''
+        from kivy import kivy_data_dir
+        from kivy.config import Config
+        from os.path import join
+        self.add_json_panel('Kivy', Config,
+                            join(kivy_data_dir, 'settings_kivy.json'))
+
+
+class SettingsWithSidebar(Settings):
+    '''A settings widget that displays settings panels with a sidebar to
+    switch between them. This is the default behaviour of
+    :class:`Settings`, and this widget is a trivial wrapper subclass.
+
+    '''
+
+
+class SettingsWithSpinner(Settings):
+    '''A settings widget that displays one settings panel at a time with a
+    spinner at the top to switch between them.
+
+    '''
+    def __init__(self, *args, **kwargs):
+        self.interface_cls = InterfaceWithSpinner
+        super(SettingsWithSpinner, self).__init__(*args, **kwargs)
+
+
+class SettingsWithTabbedPanel(Settings):
+    '''A settings widget that displays settings panels as pages in a
+    :class:`~kivy.uix.tabbedpanel.TabbedPanel`.
+    '''
+
+    __events__ = ('on_close', )
+
+    def __init__(self, *args, **kwargs):
+        self.interface_cls = InterfaceWithTabbedPanel
+        super(SettingsWithTabbedPanel, self).__init__(*args, **kwargs)
+
+    def on_close(self, *args):
+        pass
+
+
+class SettingsWithNoMenu(Settings):
+    '''A settings widget that displays a single settings panel with *no*
+    Close button. It will not accept more than one Settings panel. It
+    is intended for use in programs with few enough settings that a
+    full panel switcher is not useful.
+
+    .. warning::
+
+        This Settings panel does *not* provide a Close
+        button, and so it is impossible to leave the settings screen
+        unless you also add other behaviour or override
+        :meth:`~kivy.app.App.display_settings` and
+        :meth:`~kivy.app.App.close_settings`.
+
+    '''
+    def __init__(self, *args, **kwargs):
+        self.interface_cls = InterfaceWithNoMenu
+        super(SettingsWithNoMenu, self).__init__(*args, **kwargs)
+
+
+class InterfaceWithNoMenu(ContentPanel):
+    '''The interface widget used by :class:`SettingsWithNoMenu`. It
+    stores and displays a single settings panel.
+
+    This widget is considered internal and is not documented. See the
+    :class:`ContentPanel` for information on defining your own content
+    widget.
+
+    '''
+    def add_widget(self, *args, **kwargs):
+        if self.container is not None and len(self.container.children) > 0:
+            raise Exception(
+                'ContentNoMenu cannot accept more than one settings panel')
+        super(InterfaceWithNoMenu, self).add_widget(*args, **kwargs)
+
+
+class InterfaceWithTabbedPanel(FloatLayout):
+    '''The content widget used by :class:`SettingsWithTabbedPanel`. It
+    stores and displays Settings panels in tabs of a TabbedPanel.
+
+    This widget is considered internal and is not documented. See
+    :class:`InterfaceWithSidebar` for information on defining your own
+    interface widget.
+
+    '''
+    tabbedpanel = ObjectProperty()
+    close_button = ObjectProperty()
+
+    __events__ = ('on_close', )
+
+    def __init__(self, *args, **kwargs):
+        super(InterfaceWithTabbedPanel, self).__init__(*args, **kwargs)
+        self.close_button.bind(on_release=lambda j: self.dispatch('on_close'))
+
+    def add_panel(self, panel, name, uid):
+        scrollview = ScrollView()
+        scrollview.add_widget(panel)
+        if not self.tabbedpanel.default_tab_content:
+            self.tabbedpanel.default_tab_text = name
+            self.tabbedpanel.default_tab_content = scrollview
+        else:
+            panelitem = TabbedPanelHeader(text=name, content=scrollview)
+            self.tabbedpanel.add_widget(panelitem)
+
+    def on_close(self, *args):
+        pass
+
+
+class MenuSpinner(BoxLayout):
+    '''The menu class used by :class:`SettingsWithSpinner`. It provides a
+    sidebar with an entry for each settings panel.
+
+    This widget is considered internal and is not documented. See
+    :class:`MenuSidebar` for information on menus and creating your own menu
+    class.
+
+    '''
+    selected_uid = NumericProperty(0)
+    close_button = ObjectProperty(0)
+    spinner = ObjectProperty()
+    panel_names = DictProperty({})
+    spinner_text = StringProperty()
+    close_button = ObjectProperty()
+
+    def add_item(self, name, uid):
+        values = self.spinner.values
+        if name in values:
+            i = 2
+            while name + ' {}'.format(i) in values:
+                i += 1
+            name = name + ' {}'.format(i)
+        self.panel_names[name] = uid
+        self.spinner.values.append(name)
+        if not self.spinner.text:
+            self.spinner.text = name
+
+    def on_spinner_text(self, *args):
+        text = self.spinner_text
+        self.selected_uid = self.panel_names[text]
+
+
+class MenuSidebar(FloatLayout):
+    '''The menu used by :class:`InterfaceWithSidebar`. It provides a
+    sidebar with an entry for each settings panel, which the user may
+    click to select.
+
+    '''
+
+    selected_uid = NumericProperty(0)
+    '''The uid of the currently selected panel. This may be used to switch
+    between displayed panels, e.g. by binding it to the
+    :attr:`~ContentPanel.current_uid` of a :class:`ContentPanel`.
+
+    :attr:`selected_uid` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to 0.
+
+    '''
+
+    buttons_layout = ObjectProperty(None)
+    '''(internal) Reference to the GridLayout that contains individual
+    settings panel menu buttons.
+
+    :attr:`buttons_layout` is an
+    :class:`~kivy.properties.ObjectProperty` and defaults to None.
+
+    '''
+
+    close_button = ObjectProperty(None)
+    '''(internal) Reference to the widget's Close button.
+
+    :attr:`buttons_layout` is an
+    :class:`~kivy.properties.ObjectProperty` and defaults to None.
+
+    '''
+
+    def add_item(self, name, uid):
+        '''This method is used to add new panels to the menu.
+
+        :Parameters:
+            `name`:
+                The name (a string) of the panel. It should be used
+                to represent the panel in the menu.
+            `uid`:
+                The name (an int) of the panel. It should be used internally
+                to represent the panel and used to set self.selected_uid when
+                the panel is changed.
+
+        '''
+
+        label = SettingSidebarLabel(text=name, uid=uid, menu=self)
+        if len(self.buttons_layout.children) == 0:
+            label.selected = True
+        if self.buttons_layout is not None:
+            self.buttons_layout.add_widget(label)
+
+    def on_selected_uid(self, *args):
+        '''(internal) unselects any currently selected menu buttons, unless
+        they represent the current panel.
+
+        '''
+        for button in self.buttons_layout.children:
+            if button.uid != self.selected_uid:
+                button.selected = False
+
+
+class SettingSidebarLabel(Label):
+    # Internal class, not documented.
+    selected = BooleanProperty(False)
+    uid = NumericProperty(0)
+    menu = ObjectProperty(None)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return
+        self.selected = True
+        self.menu.selected_uid = self.uid
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+
+    class SettingsApp(App):
+        demo_json_settings = json.dumps([
+            {
+                'type': 'color',
+                'title': 'Test color',
+                'desc': 'Your choosen 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()
diff --git a/kivy/uix/slider.py b/kivy/uix/slider.py
new file mode 100644
index 0000000..740a804
--- /dev/null
+++ b/kivy/uix/slider.py
@@ -0,0 +1,421 @@
+"""
+Slider
+======
+
+.. image:: images/slider.jpg
+
+The :class:`Slider` widget looks like a scrollbar. It supports horizontal and
+vertical orientations, min/max values and a default value.
+
+To create a slider from -100 to 100 starting from 25::
+
+    from kivy.uix.slider import Slider
+    s = Slider(min=-100, max=100, value=25)
+
+To create a vertical slider::
+
+    from kivy.uix.slider import Slider
+    s = Slider(orientation='vertical')
+
+To create a slider with a red line tracking the value::
+
+    from kivy.uix.slider import Slider
+    s = Slider(value_track=True, value_track_color=[1, 0, 0, 1])
+
+
+Kv Example::
+
+    BoxLayout:
+        Slider:
+            id: slider
+            min: 0
+            max: 100
+            step: 1
+            orientation: 'vertical'
+
+        Label:
+            text: str(slider.value)
+
+"""
+__all__ = ('Slider', )
+
+from kivy.uix.widget import Widget
+from kivy.properties import (NumericProperty, AliasProperty, OptionProperty,
+                             ReferenceListProperty, BoundedNumericProperty,
+                             StringProperty, ListProperty, BooleanProperty,
+                             ColorProperty)
+
+
+class Slider(Widget):
+    """Class for creating a Slider widget.
+
+    Check module documentation for more details.
+    """
+
+    value = NumericProperty(0.)
+    '''Current value used for the slider.
+
+    :attr:`value` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0.'''
+
+    min = NumericProperty(0.)
+    '''Minimum value allowed for :attr:`value`.
+
+    :attr:`min` is a :class:`~kivy.properties.NumericProperty` and defaults to
+    0.'''
+
+    max = NumericProperty(100.)
+    '''Maximum value allowed for :attr:`value`.
+
+    :attr:`max` is a :class:`~kivy.properties.NumericProperty` and defaults to
+    100.'''
+
+    padding = NumericProperty('16sp')
+    '''Padding of the slider. The padding is used for graphical representation
+    and interaction. It prevents the cursor from going out of the bounds of the
+    slider bounding box.
+
+    By default, padding is 16sp. The range of the slider is reduced from
+    padding \\*2 on the screen. It allows drawing the default cursor of 32sp
+    width without having the cursor go out of the widget.
+
+    :attr:`padding` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 16sp.'''
+
+    orientation = OptionProperty('horizontal', options=(
+        'vertical', 'horizontal'))
+    '''Orientation of the slider.
+
+    :attr:`orientation` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'horizontal'. Can take a value of 'vertical' or 'horizontal'.
+    '''
+
+    range = ReferenceListProperty(min, max)
+    '''Range of the slider in the format (minimum value, maximum value)::
+
+        >>> slider = Slider(min=10, max=80)
+        >>> slider.range
+        [10, 80]
+        >>> slider.range = (20, 100)
+        >>> slider.min
+        20
+        >>> slider.max
+        100
+
+    :attr:`range` is a :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`min`, :attr:`max`) properties.
+    '''
+
+    step = BoundedNumericProperty(0, min=0)
+    '''Step size of the slider.
+
+    .. versionadded:: 1.4.0
+
+    Determines the size of each interval or step the slider takes between
+    :attr:`min` and :attr:`max`. If the value range can't be evenly
+    divisible by step the last step will be capped by slider.max.
+    A zero value will result in the smallest possible intervals/steps,
+    calculated from the (pixel) position of the slider.
+
+    :attr:`step` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0.'''
+
+    background_horizontal = StringProperty(
+        'atlas://data/images/defaulttheme/sliderh_background')
+    """Background of the slider used in the horizontal orientation.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`background_horizontal` is a :class:`~kivy.properties.StringProperty`
+    and defaults to `atlas://data/images/defaulttheme/sliderh_background`.
+    """
+
+    background_disabled_horizontal = StringProperty(
+        'atlas://data/images/defaulttheme/sliderh_background_disabled')
+    """Background of the disabled slider used in the horizontal orientation.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`background_disabled_horizontal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    `atlas://data/images/defaulttheme/sliderh_background_disabled`.
+    """
+
+    background_vertical = StringProperty(
+        'atlas://data/images/defaulttheme/sliderv_background')
+    """Background of the slider used in the vertical orientation.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`background_vertical` is a :class:`~kivy.properties.StringProperty`
+    and defaults to `atlas://data/images/defaulttheme/sliderv_background`.
+    """
+
+    background_disabled_vertical = StringProperty(
+        'atlas://data/images/defaulttheme/sliderv_background_disabled')
+    """Background of the disabled slider used in the vertical orientation.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`background_disabled_vertical` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    `atlas://data/images/defaulttheme/sliderv_background_disabled`.
+    """
+
+    background_width = NumericProperty('36sp')
+    """Slider's background's width (thickness), used in both horizontal
+    and vertical orientations.
+
+    .. versionadded 1.10.0
+
+    :attr:`background_width` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to 36sp.
+    """
+
+    cursor_image = StringProperty(
+        'atlas://data/images/defaulttheme/slider_cursor')
+    """Path of the image used to draw the slider cursor.
+
+    .. versionadded 1.10.0
+
+    :attr:`cursor_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to `atlas://data/images/defaulttheme/slider_cursor`.
+    """
+
+    cursor_disabled_image = StringProperty(
+        'atlas://data/images/defaulttheme/slider_cursor_disabled')
+    """Path of the image used to draw the disabled slider cursor.
+
+    .. versionadded 1.10.0
+
+    :attr:`cursor_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to `atlas://data/images/defaulttheme/slider_cursor_disabled`.
+    """
+
+    cursor_width = NumericProperty('32sp')
+    """Width of the cursor image.
+
+    .. versionadded 1.10.0
+
+    :attr:`cursor_width` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 32sp.
+    """
+
+    cursor_height = NumericProperty('32sp')
+    """Height of the cursor image.
+
+    .. versionadded 1.10.0
+
+    :attr:`cursor_height` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 32sp.
+    """
+
+    cursor_size = ReferenceListProperty(cursor_width, cursor_height)
+    """Size of the cursor image.
+
+    .. versionadded 1.10.0
+
+    :attr:`cursor_size` is a :class:`~kivy.properties.ReferenceListProperty`
+    of (:attr:`cursor_width`, :attr:`cursor_height`) properties.
+    """
+
+    border_horizontal = ListProperty([0, 18, 0, 18])
+    """Border used to draw the slider background in horizontal orientation.
+
+    .. versionadded 1.10.0
+
+    :attr:`border_horizontal` is a :class:`~kivy.properties.ListProperty`
+    and defaults to [0, 18, 0, 18].
+    """
+
+    border_vertical = ListProperty([18, 0, 18, 0])
+    """Border used to draw the slider background in vertical orientation.
+
+    .. versionadded 1.10.0
+
+    :attr:`border_horizontal` is a :class:`~kivy.properties.ListProperty`
+    and defaults to [18, 0, 18, 0].
+    """
+
+    value_track = BooleanProperty(False)
+    """Decides if slider should draw the line indicating the
+    space between :attr:`min` and :attr:`value` properties values.
+
+    .. versionadded 1.10.0
+
+    :attr:`value_track` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to False.
+    """
+
+    value_track_color = ColorProperty([1, 1, 1, 1])
+    """Color of the :attr:`value_line` in rgba format.
+
+    .. versionadded 1.10.0
+
+    :attr:`value_track_color` is a :class:`~kivy.properties.ColorProperty`
+    and defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    """
+
+    value_track_width = NumericProperty('3dp')
+    """Width of the track line.
+
+    .. versionadded 1.10.0
+
+    :attr:`value_track_width` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 3dp.
+    """
+
+    sensitivity = OptionProperty('all', options=('all', 'handle'))
+    """Whether the touch collides with the whole body of the widget
+    or with the slider handle part only.
+
+    .. versionadded:: 1.10.1
+
+    :attr:`sensitivity` is a :class:`~kivy.properties.OptionProperty`
+    and defaults to 'all'. Can take a value of 'all' or 'handle'.
+    """
+
+    # The following two methods constrain the slider's value
+    # to range(min,max). Otherwise it may happen that self.value < self.min
+    # at init.
+
+    def on_min(self, *largs):
+        self.value = min(self.max, max(self.min, self.value))
+
+    def on_max(self, *largs):
+        self.value = min(self.max, max(self.min, self.value))
+
+    def get_norm_value(self):
+        vmin = self.min
+        d = self.max - vmin
+        if d == 0:
+            return 0
+        return (self.value - vmin) / float(d)
+
+    def set_norm_value(self, value):
+        vmin = self.min
+        vmax = self.max
+        step = self.step
+        val = min(value * (vmax - vmin) + vmin, vmax)
+        if step == 0:
+            self.value = val
+        else:
+            self.value = min(round((val - vmin) / step) * step + vmin,
+                             vmax)
+
+    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`.
+    '''
+
+    def get_value_pos(self):
+        padding = self.padding
+        x = self.x
+        y = self.y
+        nval = self.value_normalized
+        if self.orientation == 'horizontal':
+            return (x + padding + nval * (self.width - 2 * padding), y)
+        else:
+            return (x, y + padding + nval * (self.height - 2 * padding))
+
+    def set_value_pos(self, pos):
+        padding = self.padding
+        x = min(self.right - padding, max(pos[0], self.x + padding))
+        y = min(self.top - padding, max(pos[1], self.y + padding))
+        if self.orientation == 'horizontal':
+            if self.width == 0:
+                self.value_normalized = 0
+            else:
+                self.value_normalized = (x - self.x - padding
+                                         ) / float(self.width - 2 * padding)
+        else:
+            if self.height == 0:
+                self.value_normalized = 0
+            else:
+                self.value_normalized = (y - self.y - padding
+                                         ) / float(self.height - 2 * padding)
+
+    value_pos = AliasProperty(get_value_pos, set_value_pos,
+                              bind=('pos', 'size', 'min', 'max', 'padding',
+                                    'value_normalized', 'orientation'),
+                              cache=True)
+    '''Position of the internal cursor, based on the normalized value.
+
+    :attr:`value_pos` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def on_touch_down(self, touch):
+        if self.disabled or not self.collide_point(*touch.pos):
+            return
+        if touch.is_mouse_scrolling:
+            if 'down' in touch.button or 'left' in touch.button:
+                if self.step:
+                    self.value = min(self.max, self.value + self.step)
+                else:
+                    self.value = min(
+                        self.max,
+                        self.value + (self.max - self.min) / 20)
+            if 'up' in touch.button or 'right' in touch.button:
+                if self.step:
+                    self.value = max(self.min, self.value - self.step)
+                else:
+                    self.value = max(
+                        self.min,
+                        self.value - (self.max - self.min) / 20)
+        elif self.sensitivity == 'handle':
+            if self.children[0].collide_point(*touch.pos):
+                touch.grab(self)
+        else:
+            touch.grab(self)
+            self.value_pos = touch.pos
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current == self:
+            self.value_pos = touch.pos
+            return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current == self:
+            self.value_pos = touch.pos
+            return True
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+
+    class SliderApp(App):
+        def build(self):
+            return Slider(padding=25)
+
+    SliderApp().run()
diff --git a/kivy/uix/spinner.py b/kivy/uix/spinner.py
new file mode 100644
index 0000000..6d38828
--- /dev/null
+++ b/kivy/uix/spinner.py
@@ -0,0 +1,221 @@
+'''
+Spinner
+=======
+
+.. versionadded:: 1.4.0
+
+.. image:: images/spinner.jpg
+    :align: right
+
+Spinner is a widget that provides a quick way to select one value from a set.
+In the default state, a spinner shows its currently selected value.
+Touching the spinner displays a dropdown menu with all the other available
+values from which the user can select a new one.
+
+Example::
+
+    from kivy.base import runTouchApp
+    from kivy.uix.spinner import Spinner
+
+    spinner = Spinner(
+        # default value shown
+        text='Home',
+        # available values
+        values=('Home', 'Work', 'Other', 'Custom'),
+        # just for positioning in our example
+        size_hint=(None, None),
+        size=(100, 44),
+        pos_hint={'center_x': .5, 'center_y': .5})
+
+    def show_selected_value(spinner, text):
+        print('The spinner', spinner, 'has text', text)
+
+    spinner.bind(text=show_selected_value)
+
+    runTouchApp(spinner)
+
+
+Kv Example::
+
+    FloatLayout:
+        Spinner:
+            size_hint: None, None
+            size: 100, 44
+            pos_hint: {'center': (.5, .5)}
+            text: 'Home'
+            values: 'Home', 'Work', 'Other', 'Custom'
+            on_text:
+                print("The spinner {} has text {}".format(self, self.text))
+'''
+
+__all__ = ('Spinner', 'SpinnerOption')
+
+from kivy.compat import string_types
+from kivy.factory import Factory
+from kivy.properties import ListProperty, ObjectProperty, BooleanProperty
+from kivy.uix.button import Button
+from kivy.uix.dropdown import DropDown
+
+
+class SpinnerOption(Button):
+    '''Special button used in the :class:`Spinner` dropdown list. By default,
+    this is just a :class:`~kivy.uix.button.Button` with a size_hint_y of None
+    and a height of :meth:`48dp <kivy.metrics.dp>`.
+    '''
+    pass
+
+
+class Spinner(Button):
+    '''Spinner class, see module documentation for more information.
+    '''
+
+    values = ListProperty()
+    '''Values that can be selected by the user. It must be a list of strings.
+
+    :attr:`values` is a :class:`~kivy.properties.ListProperty` and defaults to
+    [].
+    '''
+
+    text_autoupdate = BooleanProperty(False)
+    '''Indicates if the spinner's :attr:`text` should be automatically
+    updated with the first value of the :attr:`values` property.
+    Setting it to True will cause the spinner to update its :attr:`text`
+    property every time attr:`values` are changed.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`text_autoupdate` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    option_cls = ObjectProperty(SpinnerOption)
+    '''Class used to display the options within the dropdown list displayed
+    under the Spinner. The `text` property of the class will be used to
+    represent the value.
+
+    The option class requires:
+
+    - a `text` property, used to display the value.
+    - an `on_release` event, used to trigger the option when pressed/touched.
+    - a :attr:`~kivy.uix.widget.Widget.size_hint_y` of None.
+    - the :attr:`~kivy.uix.widget.Widget.height` to be set.
+
+    :attr:`option_cls` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to :class:`SpinnerOption`.
+
+    .. versionchanged:: 1.8.0
+        If you set a string, the :class:`~kivy.factory.Factory` will be used to
+        resolve the class.
+
+    '''
+
+    dropdown_cls = ObjectProperty(DropDown)
+    '''Class used to display the dropdown list when the Spinner is pressed.
+
+    :attr:`dropdown_cls` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to :class:`~kivy.uix.dropdown.DropDown`.
+
+    .. versionchanged:: 1.8.0
+        If set to a string, the :class:`~kivy.factory.Factory` will be used to
+        resolve the class name.
+
+    '''
+
+    is_open = BooleanProperty(False)
+    '''By default, the spinner is not open. Set to True to open it.
+
+    :attr:`is_open` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+
+    .. versionadded:: 1.4.0
+    '''
+
+    sync_height = BooleanProperty(False)
+    '''Each element in a dropdown list uses a default/user-supplied height.
+    Set to True to propagate the Spinner's height value to each dropdown
+    list element.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`sync_height` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    def __init__(self, **kwargs):
+        self._dropdown = None
+        super(Spinner, self).__init__(**kwargs)
+        fbind = self.fbind
+        build_dropdown = self._build_dropdown
+        fbind('on_release', self._toggle_dropdown)
+        fbind('dropdown_cls', build_dropdown)
+        fbind('option_cls', build_dropdown)
+        fbind('values', self._update_dropdown)
+        fbind('size', self._update_dropdown_size)
+        fbind('text_autoupdate', self._update_dropdown)
+        build_dropdown()
+
+    def _build_dropdown(self, *largs):
+        if self._dropdown:
+            self._dropdown.unbind(on_select=self._on_dropdown_select)
+            self._dropdown.unbind(on_dismiss=self._close_dropdown)
+            self._dropdown.dismiss()
+            self._dropdown = None
+        cls = self.dropdown_cls
+        if isinstance(cls, string_types):
+            cls = Factory.get(cls)
+        self._dropdown = cls()
+        self._dropdown.bind(on_select=self._on_dropdown_select)
+        self._dropdown.bind(on_dismiss=self._close_dropdown)
+        self._update_dropdown()
+
+    def _update_dropdown_size(self, *largs):
+        if not self.sync_height:
+            return
+        dp = self._dropdown
+        if not dp:
+            return
+
+        container = dp.container
+        if not container:
+            return
+        h = self.height
+        for item in container.children[:]:
+            item.height = h
+
+    def _update_dropdown(self, *largs):
+        dp = self._dropdown
+        cls = self.option_cls
+        values = self.values
+        text_autoupdate = self.text_autoupdate
+        if isinstance(cls, string_types):
+            cls = Factory.get(cls)
+        dp.clear_widgets()
+        for value in values:
+            item = cls(text=value)
+            item.height = self.height if self.sync_height else item.height
+            item.bind(on_release=lambda option: dp.select(option.text))
+            dp.add_widget(item)
+        if text_autoupdate:
+            if values:
+                if not self.text or self.text not in values:
+                    self.text = values[0]
+            else:
+                self.text = ''
+
+    def _toggle_dropdown(self, *largs):
+        if self.values:
+            self.is_open = not self.is_open
+
+    def _close_dropdown(self, *largs):
+        self.is_open = False
+
+    def _on_dropdown_select(self, instance, data, *largs):
+        self.text = data
+        self.is_open = False
+
+    def on_is_open(self, instance, value):
+        if value:
+            self._dropdown.open(self)
+        else:
+            if self._dropdown.attach_to:
+                self._dropdown.dismiss()
diff --git a/kivy/uix/splitter.py b/kivy/uix/splitter.py
new file mode 100644
index 0000000..233d57b
--- /dev/null
+++ b/kivy/uix/splitter.py
@@ -0,0 +1,430 @@
+'''Splitter
+======
+
+.. versionadded:: 1.5.0
+
+.. image:: images/splitter.jpg
+    :align: right
+
+The :class:`Splitter` is a widget that helps you re-size its child
+widget/layout by letting you re-size it via dragging the boundary or
+double tapping the boundary. This widget is similar to the
+:class:`~kivy.uix.scrollview.ScrollView` in that it allows only one
+child widget.
+
+Usage::
+
+    splitter = Splitter(sizable_from = 'right')
+    splitter.add_widget(layout_or_widget_instance)
+    splitter.min_size = 100
+    splitter.max_size = 250
+
+To change the size of the strip/border used for resizing::
+
+    splitter.strip_size = '10pt'
+
+To change its appearance::
+
+    splitter.strip_cls = your_custom_class
+
+You can also change the appearance of the `strip_cls`, which defaults to
+:class:`SplitterStrip`, by overriding the `kv` rule in your app:
+
+.. code-block:: kv
+
+    <SplitterStrip>:
+        horizontal: True if self.parent and self.parent.sizable_from[0] \
+in ('t', 'b') else False
+        background_normal: 'path to normal horizontal image' \
+if self.horizontal else 'path to vertical normal image'
+        background_down: 'path to pressed horizontal image' \
+if self.horizontal else 'path to vertical pressed image'
+
+'''
+
+
+__all__ = ('Splitter', )
+
+from kivy.compat import string_types
+from kivy.factory import Factory
+from kivy.uix.button import Button
+from kivy.properties import (OptionProperty, NumericProperty, ObjectProperty,
+                             ListProperty, BooleanProperty)
+from kivy.uix.boxlayout import BoxLayout
+
+
+class SplitterStrip(Button):
+    '''Class used for the graphical representation of a
+    :class:`kivy.uix.splitter.SplitterStripe`.
+    '''
+    pass
+
+
+class Splitter(BoxLayout):
+    '''See module documentation.
+
+    :Events:
+        `on_press`:
+            Fired when the splitter is pressed.
+        `on_release`:
+            Fired when the splitter is released.
+
+    .. versionchanged:: 1.6.0
+        Added `on_press` and `on_release` events.
+
+    '''
+
+    border = ListProperty([4, 4, 4, 4])
+    '''Border used for the
+    :class:`~kivy.graphics.vertex_instructions.BorderImage`
+    graphics instruction.
+
+    This must be a list of four values: (bottom, right, top, left).
+    Read the BorderImage instructions for more information about how
+    to use it.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and
+    defaults to (4, 4, 4, 4).
+    '''
+
+    strip_cls = ObjectProperty(SplitterStrip)
+    '''Specifies the class of the resize Strip.
+
+    :attr:`strip_cls` is an :class:`kivy.properties.ObjectProperty` and
+    defaults to :class:`~kivy.uix.splitter.SplitterStrip`, which is of type
+    :class:`~kivy.uix.button.Button`.
+
+    .. versionchanged:: 1.8.0
+        If you set a string, the :class:`~kivy.factory.Factory` will be used to
+        resolve the class.
+
+    '''
+
+    sizable_from = OptionProperty('left', options=(
+        'left', 'right', 'top', 'bottom'))
+    '''Specifies whether the widget is resizable. Options are:
+    `left`, `right`, `top` or `bottom`
+
+    :attr:`sizable_from` is an :class:`~kivy.properties.OptionProperty`
+    and defaults to `left`.
+    '''
+
+    strip_size = NumericProperty('10pt')
+    '''Specifies the size of resize strip
+
+    :attr:`strp_size` is a :class:`~kivy.properties.NumericProperty`
+    defaults to `10pt`
+    '''
+
+    min_size = NumericProperty('100pt')
+    '''Specifies the minimum size beyond which the widget is not resizable.
+
+    :attr:`min_size` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to `100pt`.
+    '''
+
+    max_size = NumericProperty('500pt')
+    '''Specifies the maximum size beyond which the widget is not resizable.
+
+    :attr:`max_size` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to `500pt`.
+    '''
+
+    _parent_proportion = NumericProperty(0.)
+    '''(internal) Specifies the distance that the slider has travelled
+    across its parent, used to automatically maintain a sensible
+    position if the parent is resized.
+
+    :attr:`_parent_proportion` is a
+    :class:`~kivy.properties.NumericProperty` and defaults to 0.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    _bound_parent = ObjectProperty(None, allownone=True)
+    '''(internal) References the widget whose size is currently being
+    tracked by :attr:`_parent_proportion`.
+
+    :attr:`_bound_parent` is a
+    :class:`~kivy.properties.ObjectProperty` and defaults to None.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    keep_within_parent = BooleanProperty(False)
+    '''If True, will limit the splitter to stay within its parent widget.
+
+    :attr:`keep_within_parent` is a
+    :class:`~kivy.properties.BooleanProperty` and defaults to False.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    rescale_with_parent = BooleanProperty(False)
+    '''If True, will automatically change size to take up the same
+    proportion of the parent widget when it is resized, while
+    staying within :attr:`min_size` and :attr:`max_size`. As long as
+    these attributes can be satisfied, this stops the
+    :class:`Splitter` from exceeding the parent size during rescaling.
+
+    :attr:`rescale_with_parent` is a
+    :class:`~kivy.properties.BooleanProperty` and defaults to False.
+
+    .. versionadded:: 1.9.0
+    '''
+
+    __events__ = ('on_press', 'on_release')
+
+    def __init__(self, **kwargs):
+        self._container = None
+        self._strip = None
+        super(Splitter, self).__init__(**kwargs)
+
+        do_size = self._do_size
+        fbind = self.fbind
+        fbind('max_size', do_size)
+        fbind('min_size', do_size)
+        fbind('parent', self._rebind_parent)
+
+    def on_sizable_from(self, instance, sizable_from):
+        if not instance._container:
+            return
+
+        sup = super(Splitter, instance)
+        _strp = instance._strip
+        if _strp:
+            # remove any previous binds
+            _strp.unbind(on_touch_down=instance.strip_down)
+            _strp.unbind(on_touch_move=instance.strip_move)
+            _strp.unbind(on_touch_up=instance.strip_up)
+            self.unbind(disabled=_strp.setter('disabled'))
+
+            sup.remove_widget(instance._strip)
+        else:
+            cls = instance.strip_cls
+            if isinstance(cls, string_types):
+                cls = Factory.get(cls)
+            instance._strip = _strp = cls()
+
+        sz_frm = instance.sizable_from[0]
+        if sz_frm in ('l', 'r'):
+            _strp.size_hint = None, 1
+            _strp.width = instance.strip_size
+            instance.orientation = 'horizontal'
+            instance.unbind(strip_size=_strp.setter('width'))
+            instance.bind(strip_size=_strp.setter('width'))
+        else:
+            _strp.size_hint = 1, None
+            _strp.height = instance.strip_size
+            instance.orientation = 'vertical'
+            instance.unbind(strip_size=_strp.setter('height'))
+            instance.bind(strip_size=_strp.setter('height'))
+
+        index = 1
+        if sz_frm in ('r', 'b'):
+            index = 0
+        sup.add_widget(_strp, index)
+
+        _strp.bind(on_touch_down=instance.strip_down)
+        _strp.bind(on_touch_move=instance.strip_move)
+        _strp.bind(on_touch_up=instance.strip_up)
+        _strp.disabled = self.disabled
+        self.bind(disabled=_strp.setter('disabled'))
+
+    def add_widget(self, widget, index=0, *args, **kwargs):
+        if self._container or not widget:
+            return Exception('Splitter accepts only one Child')
+        self._container = widget
+        sz_frm = self.sizable_from[0]
+        if sz_frm in ('l', 'r'):
+            widget.size_hint_x = 1
+        else:
+            widget.size_hint_y = 1
+
+        index = 0
+        if sz_frm in ('r', 'b'):
+            index = 1
+        super(Splitter, self).add_widget(widget, index, *args, **kwargs)
+        self.on_sizable_from(self, self.sizable_from)
+
+    def remove_widget(self, widget, *args, **kwargs):
+        super(Splitter, self).remove_widget(widget, *args, **kwargs)
+        if widget == self._container:
+            self._container = None
+
+    def clear_widgets(self, *args, **kwargs):
+        self.remove_widget(self._container)
+
+    def strip_down(self, instance, touch):
+        if not instance.collide_point(*touch.pos):
+            return False
+        touch.grab(self)
+        self.dispatch('on_press')
+
+    def on_press(self):
+        pass
+
+    def _rebind_parent(self, instance, new_parent):
+        if self._bound_parent is not None:
+            self._bound_parent.unbind(size=self.rescale_parent_proportion)
+        if self.parent is not None:
+            new_parent.bind(size=self.rescale_parent_proportion)
+        self._bound_parent = new_parent
+        self.rescale_parent_proportion()
+
+    def rescale_parent_proportion(self, *args):
+        if not self.parent:
+            return
+        if self.rescale_with_parent:
+            parent_proportion = self._parent_proportion
+            if self.sizable_from in ('top', 'bottom'):
+                new_height = parent_proportion * self.parent.height
+                self.height = max(self.min_size,
+                                 min(new_height, self.max_size))
+            else:
+                new_width = parent_proportion * self.parent.width
+                self.width = max(self.min_size, min(new_width, self.max_size))
+
+    def _do_size(self, instance, value):
+        if self.sizable_from[0] in ('l', 'r'):
+            self.width = max(self.min_size, min(self.width, self.max_size))
+        else:
+            self.height = max(self.min_size, min(self.height, self.max_size))
+
+    @staticmethod
+    def _is_moving(sz_frm, diff, pos, minpos, maxpos):
+        if sz_frm in ('l', 'b'):
+            cmp = minpos
+        else:
+            cmp = maxpos
+        if diff == 0:
+            return False
+        elif diff > 0 and pos <= cmp:
+            return False
+        elif diff < 0 and pos >= cmp:
+            return False
+        return True
+
+    def strip_move(self, instance, touch):
+        if touch.grab_current is not instance:
+            return False
+        max_size = self.max_size
+        min_size = self.min_size
+        sz_frm = self.sizable_from[0]
+
+        if sz_frm in ('t', 'b'):
+            diff_y = (touch.dy)
+            self_y = self.y
+            self_top = self.top
+            if not self._is_moving(sz_frm, diff_y, touch.y, self_y, self_top):
+                return
+            if self.keep_within_parent:
+                if sz_frm == 't' and (self_top + diff_y) > self.parent.top:
+                    diff_y = self.parent.top - self_top
+                elif sz_frm == 'b' and (self_y + diff_y) < self.parent.y:
+                    diff_y = self.parent.y - self_y
+            if sz_frm == 'b':
+                diff_y *= -1
+            if self.size_hint_y:
+                self.size_hint_y = None
+            if self.height > 0:
+                self.height += diff_y
+            else:
+                self.height = 1
+
+            height = self.height
+            self.height = max(min_size, min(height, max_size))
+
+            self._parent_proportion = self.height / self.parent.height
+        else:
+            diff_x = (touch.dx)
+            self_x = self.x
+            self_right = self.right
+            if not self._is_moving(sz_frm, diff_x, touch.x, self_x, self_right):
+                return
+            if self.keep_within_parent:
+                if sz_frm == 'l' and (self_x + diff_x) < self.parent.x:
+                    diff_x = self.parent.x - self_x
+                elif (sz_frm == 'r' and
+                      (self_right + diff_x) > self.parent.right):
+                    diff_x = self.parent.right - self_right
+            if sz_frm == 'l':
+                diff_x *= -1
+            if self.size_hint_x:
+                self.size_hint_x = None
+            if self.width > 0:
+                self.width += diff_x
+            else:
+                self.width = 1
+
+            width = self.width
+            self.width = max(min_size, min(width, max_size))
+
+            self._parent_proportion = self.width / self.parent.width
+
+    def strip_up(self, instance, touch):
+        if touch.grab_current is not instance:
+            return
+
+        if touch.is_double_tap:
+            max_size = self.max_size
+            min_size = self.min_size
+            sz_frm = self.sizable_from[0]
+            s = self.size
+
+            if sz_frm in ('t', 'b'):
+                if self.size_hint_y:
+                    self.size_hint_y = None
+                if s[1] - min_size <= max_size - s[1]:
+                    self.height = max_size
+                else:
+                    self.height = min_size
+            else:
+                if self.size_hint_x:
+                    self.size_hint_x = None
+                if s[0] - min_size <= max_size - s[0]:
+                    self.width = max_size
+                else:
+                    self.width = min_size
+        touch.ungrab(instance)
+        self.dispatch('on_release')
+
+    def on_release(self):
+        pass
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+    from kivy.uix.button import Button
+    from kivy.uix.floatlayout import FloatLayout
+
+    class SplitterApp(App):
+
+        def build(self):
+            root = FloatLayout()
+            bx = BoxLayout()
+            bx.add_widget(Button())
+            bx.add_widget(Button())
+            bx2 = BoxLayout()
+            bx2.add_widget(Button())
+            bx2.add_widget(Button())
+            bx2.add_widget(Button())
+            spl = Splitter(
+                size_hint=(1, .25),
+                pos_hint={'top': 1},
+                sizable_from='bottom')
+            spl1 = Splitter(
+                sizable_from='left',
+                size_hint=(None, 1), width=90)
+            spl1.add_widget(Button())
+            bx.add_widget(spl1)
+            spl.add_widget(bx)
+
+            spl2 = Splitter(size_hint=(.25, 1))
+            spl2.add_widget(bx2)
+            spl2.sizable_from = 'right'
+            root.add_widget(spl)
+            root.add_widget(spl2)
+            return root
+
+    SplitterApp().run()
diff --git a/kivy/uix/stacklayout.py b/kivy/uix/stacklayout.py
new file mode 100644
index 0000000..1447138
--- /dev/null
+++ b/kivy/uix/stacklayout.py
@@ -0,0 +1,331 @@
+'''
+Stack Layout
+============
+
+.. only:: html
+
+    .. image:: images/stacklayout.gif
+        :align: right
+
+.. only:: latex
+
+    .. image:: images/stacklayout.png
+        :align: right
+
+.. versionadded:: 1.0.5
+
+The :class:`StackLayout` arranges children vertically or horizontally, as many
+as the layout can fit. The size of the individual children widgets do not
+have to be uniform.
+
+For example, to display widgets that get progressively larger in width::
+
+    root = StackLayout()
+    for i in range(25):
+        btn = Button(text=str(i), width=40 + i * 5, size_hint=(None, 0.15))
+        root.add_widget(btn)
+
+.. image:: images/stacklayout_sizing.png
+    :align: left
+'''
+
+__all__ = ('StackLayout', )
+
+from kivy.uix.layout import Layout
+from kivy.properties import NumericProperty, OptionProperty, \
+    ReferenceListProperty, VariableListProperty
+
+
+def _compute_size(c, available_size, idx):
+    sh_min = c.size_hint_min[idx]
+    sh_max = c.size_hint_max[idx]
+    val = c.size_hint[idx] * available_size
+
+    if sh_min is not None:
+        if sh_max is not None:
+            return max(min(sh_max, val), sh_min)
+        return max(val, sh_min)
+    if sh_max is not None:
+        return min(sh_max, val)
+    return val
+
+
+class StackLayout(Layout):
+    '''Stack layout class. See module documentation for more information.
+    '''
+
+    spacing = VariableListProperty([0, 0], length=2)
+    '''Spacing between children: [spacing_horizontal, spacing_vertical].
+
+    spacing also accepts a single argument form [spacing].
+
+    :attr:`spacing` is a
+    :class:`~kivy.properties.VariableListProperty` and defaults to [0, 0].
+
+    '''
+
+    padding = VariableListProperty([0, 0, 0, 0])
+    '''Padding between the layout box and it's children: [padding_left,
+    padding_top, padding_right, padding_bottom].
+
+    padding also accepts a two argument form [padding_horizontal,
+    padding_vertical] and a single argument form [padding].
+
+    .. versionchanged:: 1.7.0
+        Replaced the NumericProperty with a VariableListProperty.
+
+    :attr:`padding` is a
+    :class:`~kivy.properties.VariableListProperty` and defaults to
+    [0, 0, 0, 0].
+
+    '''
+
+    orientation = OptionProperty('lr-tb', options=(
+        'lr-tb', 'tb-lr', 'rl-tb', 'tb-rl', 'lr-bt', 'bt-lr', 'rl-bt',
+        'bt-rl'))
+    '''Orientation of the layout.
+
+    :attr:`orientation` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'lr-tb'.
+
+    Valid orientations are 'lr-tb', 'tb-lr', 'rl-tb', 'tb-rl', 'lr-bt',
+    'bt-lr', 'rl-bt' and 'bt-rl'.
+
+    .. versionchanged:: 1.5.0
+        :attr:`orientation` now correctly handles all valid combinations of
+        'lr','rl','tb','bt'. Before this version only 'lr-tb' and
+        'tb-lr' were supported, and 'tb-lr' was misnamed and placed
+        widgets from bottom to top and from right to left (reversed compared
+        to what was expected).
+
+    .. note::
+
+        'lr' means Left to Right.
+        'rl' means Right to Left.
+        'tb' means Top to Bottom.
+        'bt' means Bottom to Top.
+    '''
+
+    minimum_width = NumericProperty(0)
+    '''Minimum width needed to contain all children. It is automatically set
+    by the layout.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`minimum_width` is a :class:`kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    minimum_height = NumericProperty(0)
+    '''Minimum height needed to contain all children. It is automatically set
+    by the layout.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`minimum_height` is a :class:`kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    minimum_size = ReferenceListProperty(minimum_width, minimum_height)
+    '''Minimum size needed to contain all children. It is automatically set
+    by the layout.
+
+    .. versionadded:: 1.0.8
+
+    :attr:`minimum_size` is a
+    :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`minimum_width`, :attr:`minimum_height`) properties.
+    '''
+
+    def __init__(self, **kwargs):
+        super(StackLayout, self).__init__(**kwargs)
+        trigger = self._trigger_layout
+        fbind = self.fbind
+        fbind('padding', trigger)
+        fbind('spacing', trigger)
+        fbind('children', trigger)
+        fbind('orientation', trigger)
+        fbind('size', trigger)
+        fbind('pos', trigger)
+
+    def do_layout(self, *largs):
+        if not self.children:
+            self.minimum_size = (0., 0.)
+            return
+
+        # optimize layout by preventing looking at the same attribute in a loop
+        selfpos = self.pos
+        selfsize = self.size
+        orientation = self.orientation.split('-')
+        padding_left = self.padding[0]
+        padding_top = self.padding[1]
+        padding_right = self.padding[2]
+        padding_bottom = self.padding[3]
+
+        padding_x = padding_left + padding_right
+        padding_y = padding_top + padding_bottom
+        spacing_x, spacing_y = self.spacing
+
+        # Determine which direction and in what order to place the widgets
+        posattr = [0] * 2
+        posdelta = [0] * 2
+        posstart = [0] * 2
+        for i in (0, 1):
+            posattr[i] = 1 * (orientation[i] in ('tb', 'bt'))
+            k = posattr[i]
+            if orientation[i] == 'lr':
+                # left to right
+                posdelta[i] = 1
+                posstart[i] = selfpos[k] + padding_left
+            elif orientation[i] == 'bt':
+                # bottom to top
+                posdelta[i] = 1
+                posstart[i] = selfpos[k] + padding_bottom
+            elif orientation[i] == 'rl':
+                # right to left
+                posdelta[i] = -1
+                posstart[i] = selfpos[k] + selfsize[k] - padding_right
+            else:
+                # top to bottom
+                posdelta[i] = -1
+                posstart[i] = selfpos[k] + selfsize[k] - padding_top
+
+        innerattr, outerattr = posattr
+        ustart, vstart = posstart
+        deltau, deltav = posdelta
+        del posattr, posdelta, posstart
+
+        u = ustart  # inner loop position variable
+        v = vstart  # outer loop position variable
+
+        # space calculation, used for determining when a row or column is full
+
+        if orientation[0] in ('lr', 'rl'):
+            sv = padding_y  # size in v-direction, for minimum_size property
+            su = padding_x  # size in h-direction
+            spacing_u = spacing_x
+            spacing_v = spacing_y
+            padding_u = padding_x
+            padding_v = padding_y
+        else:
+            sv = padding_x  # size in v-direction, for minimum_size property
+            su = padding_y  # size in h-direction
+            spacing_u = spacing_y
+            spacing_v = spacing_x
+            padding_u = padding_y
+            padding_v = padding_x
+
+        # space calculation, row height or column width, for arranging widgets
+        lv = 0
+
+        urev = (deltau < 0)
+        vrev = (deltav < 0)
+        firstchild = self.children[0]
+        sizes = []
+        lc = []
+        for c in reversed(self.children):
+            if c.size_hint[outerattr] is not None:
+                c.size[outerattr] = max(
+                    1, _compute_size(c, selfsize[outerattr] - padding_v,
+                                     outerattr))
+
+            # does the widget fit in the row/column?
+            ccount = len(lc)
+            totalsize = availsize = max(
+                0, selfsize[innerattr] - padding_u - spacing_u * ccount)
+            if not lc:
+                if c.size_hint[innerattr] is not None:
+                    childsize = max(1, _compute_size(c, totalsize, innerattr))
+                else:
+                    childsize = max(0, c.size[innerattr])
+                availsize = selfsize[innerattr] - padding_u - childsize
+                testsizes = [childsize]
+            else:
+                testsizes = [0] * (ccount + 1)
+                for i, child in enumerate(lc):
+                    if availsize <= 0:
+                        # no space left but we're trying to add another widget.
+                        availsize = -1
+                        break
+                    if child.size_hint[innerattr] is not None:
+                        testsizes[i] = childsize = max(
+                            1, _compute_size(child, totalsize, innerattr))
+                    else:
+                        childsize = max(0, child.size[innerattr])
+                        testsizes[i] = childsize
+                    availsize -= childsize
+                if c.size_hint[innerattr] is not None:
+                    testsizes[-1] = max(
+                        1, _compute_size(c, totalsize, innerattr))
+                else:
+                    testsizes[-1] = max(0, c.size[innerattr])
+                availsize -= testsizes[-1]
+
+            # Tiny value added in order to avoid issues with float precision
+            # causing unexpected children reordering when parent resizes.
+            # e.g. if size is 101 and children size_hint_x is 1./5
+            # 5 children would not fit in one line because 101*(1./5) > 101/5
+            if (availsize + 1e-10) >= 0 or not lc:
+                # even if there's no space, we always add one widget to a row
+                lc.append(c)
+                sizes = testsizes
+                lv = max(lv, c.size[outerattr])
+                continue
+
+            # apply the sizes
+            for i, child in enumerate(lc):
+                if child.size_hint[innerattr] is not None:
+                    child.size[innerattr] = sizes[i]
+
+            # push the line
+            sv += lv + spacing_v
+            for c2 in lc:
+                if urev:
+                    u -= c2.size[innerattr]
+                c2.pos[innerattr] = u
+                pos_outer = v
+                if vrev:
+                    # v position is actually the top/right side of the widget
+                    # when going from high to low coordinate values,
+                    # we need to subtract the height/width from the position.
+                    pos_outer -= c2.size[outerattr]
+                c2.pos[outerattr] = pos_outer
+                if urev:
+                    u -= spacing_u
+                else:
+                    u += c2.size[innerattr] + spacing_u
+
+            v += deltav * lv
+            v += deltav * spacing_v
+            lc = [c]
+            lv = c.size[outerattr]
+            if c.size_hint[innerattr] is not None:
+                sizes = [
+                    max(1, _compute_size(c, selfsize[innerattr] - padding_u,
+                                         innerattr))]
+            else:
+                sizes = [max(0, c.size[innerattr])]
+            u = ustart
+
+        if lc:
+            # apply the sizes
+            for i, child in enumerate(lc):
+                if child.size_hint[innerattr] is not None:
+                    child.size[innerattr] = sizes[i]
+
+            # push the last (incomplete) line
+            sv += lv + spacing_v
+            for c2 in lc:
+                if urev:
+                    u -= c2.size[innerattr]
+                c2.pos[innerattr] = u
+                pos_outer = v
+                if vrev:
+                    pos_outer -= c2.size[outerattr]
+                c2.pos[outerattr] = pos_outer
+                if urev:
+                    u -= spacing_u
+                else:
+                    u += c2.size[innerattr] + spacing_u
+
+        self.minimum_size[outerattr] = sv
diff --git a/kivy/uix/stencilview.py b/kivy/uix/stencilview.py
new file mode 100644
index 0000000..5970372
--- /dev/null
+++ b/kivy/uix/stencilview.py
@@ -0,0 +1,40 @@
+'''
+Stencil View
+============
+
+.. image:: images/stencilview.gif
+    :align: right
+
+.. versionadded:: 1.0.4
+
+:class:`StencilView` limits the drawing of child widgets to the StencilView's
+bounding box. Any drawing outside the bounding box will be clipped (trashed).
+
+The StencilView uses the stencil graphics instructions under the hood. It
+provides an efficient way to clip the drawing area of children.
+
+.. note::
+
+    As with the stencil graphics instructions, you cannot stack more than 128
+    stencil-aware widgets.
+
+.. note::
+
+    StencilView is not a layout. Consequently, you have to manage the size and
+    position of its children directly. You can combine (subclass both)
+    a StencilView and a Layout in order to achieve a layout's behavior.
+    For example::
+
+        class BoxStencil(BoxLayout, StencilView):
+            pass
+'''
+
+__all__ = ('StencilView', )
+
+from kivy.uix.widget import Widget
+
+
+class StencilView(Widget):
+    '''StencilView class. See module documentation for more information.
+    '''
+    pass
diff --git a/kivy/uix/switch.py b/kivy/uix/switch.py
new file mode 100644
index 0000000..910bbf5
--- /dev/null
+++ b/kivy/uix/switch.py
@@ -0,0 +1,122 @@
+'''
+Switch
+======
+
+.. versionadded:: 1.0.7
+
+.. image:: images/switch-on.jpg
+    :align: right
+
+.. image:: images/switch-off.jpg
+    :align: right
+
+The :class:`Switch` widget is active or inactive, like a mechanical light
+switch. The user can swipe to the left/right to activate/deactivate it::
+
+    switch = Switch(active=True)
+
+To attach a callback that listens to the activation state::
+
+    def callback(instance, value):
+        print('the switch', instance, 'is', value)
+
+    switch = Switch()
+    switch.bind(active=callback)
+
+By default, the representation of the widget is static. The minimum size
+required is 83x32 pixels (defined by the background image). The image is
+centered within the widget.
+
+The entire widget is active, not just the part with graphics. As long as you
+swipe over the widget's bounding box, it will work.
+
+.. note::
+
+    If you want to control the state with a single touch instead of a swipe,
+    use the :class:`ToggleButton` instead.
+
+Kv Example::
+
+    BoxLayout:
+        Label:
+            text: 'power up'
+        Switch:
+            id: switch
+        Label:
+            text: 'woooooooooooh' if switch.active else ''
+'''
+
+
+from kivy.uix.widget import Widget
+from kivy.animation import Animation
+from kivy.properties import BooleanProperty, ObjectProperty, NumericProperty
+
+
+class Switch(Widget):
+    '''Switch class. See module documentation for more information.
+    '''
+    active = BooleanProperty(False)
+    '''Indicate whether the switch is active or inactive.
+
+    :attr:`active` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    touch_control = ObjectProperty(None, allownone=True)
+    '''(internal) Contains the touch that currently interacts with the switch.
+
+    :attr:`touch_control` is an :class:`~kivy.properties.ObjectProperty`
+    and defaults to None.
+    '''
+
+    touch_distance = NumericProperty(0)
+    '''(internal) Contains the distance between the initial position of the
+    touch and the current position to determine if the swipe is from the left
+    or right.
+
+    :attr:`touch_distance` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    active_norm_pos = NumericProperty(0)
+    '''(internal) Contains the normalized position of the movable element
+    inside the switch, in the 0-1 range.
+
+    :attr:`active_norm_pos` is a :class:`~kivy.properties.NumericProperty`
+    and defaults to 0.
+    '''
+
+    def on_touch_down(self, touch):
+        if self.disabled or self.touch_control is not None:
+            return
+        if not self.collide_point(*touch.pos):
+            return
+        touch.grab(self)
+        self.touch_distance = 0
+        self.touch_control = touch
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is not self:
+            return
+        self.touch_distance = touch.x - touch.ox
+        return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+        # depending of the distance, activate by norm pos or invert
+        if abs(touch.ox - touch.x) < 5:
+            self.active = not self.active
+        else:
+            self.active = self.active_norm_pos > 0.5
+        Animation(active_norm_pos=int(self.active), t='out_quad',
+                  d=.2).start(self)
+        self.touch_control = None
+        return True
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    runTouchApp(Switch())
diff --git a/kivy/uix/tabbedpanel.py b/kivy/uix/tabbedpanel.py
new file mode 100644
index 0000000..8841159
--- /dev/null
+++ b/kivy/uix/tabbedpanel.py
@@ -0,0 +1,856 @@
+'''
+TabbedPanel
+===========
+
+.. image:: images/tabbed_panel.jpg
+    :align: right
+
+.. versionadded:: 1.3.0
+
+
+The `TabbedPanel` widget manages different widgets in tabs, with a header area
+for the actual tab buttons and a content area for showing the current tab
+content.
+
+The :class:`TabbedPanel` provides one default tab.
+
+Simple example
+--------------
+
+.. include:: ../../examples/widgets/tabbedpanel.py
+    :literal:
+
+.. note::
+
+    A new class :class:`TabbedPanelItem` has been introduced in 1.5.0 for
+    convenience. So now one can simply add a :class:`TabbedPanelItem` to a
+    :class:`TabbedPanel` and `content` to the :class:`TabbedPanelItem`
+    as in the example provided above.
+
+Customize the Tabbed Panel
+--------------------------
+
+You can choose the position in which the tabs are displayed::
+
+    tab_pos = 'top_mid'
+
+An individual tab is called a TabbedPanelHeader. It is a special button
+containing a `content` property. You add the TabbedPanelHeader first, and set
+its `content` property separately::
+
+    tp = TabbedPanel()
+    th = TabbedPanelHeader(text='Tab2')
+    tp.add_widget(th)
+
+An individual tab, represented by a TabbedPanelHeader, needs its content set.
+This content can be any widget. It could be a layout with a deep
+hierarchy of widgets, or it could be an individual widget, such as a label or a
+button::
+
+    th.content = your_content_instance
+
+There is one "shared" main content area active at any given time, for all
+the tabs. Your app is responsible for adding the content of individual tabs
+and for managing them, but it's not responsible for content switching. The
+tabbed panel handles switching of the main content object as per user action.
+
+There is a default tab added when the tabbed panel is instantiated.
+Tabs that you add individually as above, are added in addition to the default
+tab. Thus, depending on your needs and design, you will want to customize the
+default tab::
+
+    tp.default_tab_text = 'Something Specific To Your Use'
+
+
+The default tab machinery requires special consideration and management.
+Accordingly, an `on_default_tab` event is provided for associating a callback::
+
+    tp.bind(default_tab = my_default_tab_callback)
+
+It's important to note that by default, :attr:`default_tab_cls` is of type
+:class:`TabbedPanelHeader` and thus has the same properties as other tabs.
+
+Since 1.5.0, it is now possible to disable the creation of the
+:attr:`default_tab` by setting :attr:`do_default_tab` to False.
+
+Tabs and content can be removed in several ways::
+
+    tp.remove_widget(widget/tabbed_panel_header)
+    or
+    tp.clear_widgets() # to clear all the widgets in the content area
+    or
+    tp.clear_tabs() # to remove the TabbedPanelHeaders
+
+To access the children of the tabbed panel, use content.children::
+
+    tp.content.children
+
+To access the list of tabs::
+
+    tp.tab_list
+
+To change the appearance of the main tabbed panel content::
+
+    background_color = (1, 0, 0, .5) #50% translucent red
+    border = [0, 0, 0, 0]
+    background_image = 'path/to/background/image'
+
+To change the background of a individual tab, use these two properties::
+
+    tab_header_instance.background_normal = 'path/to/tab_head/img'
+    tab_header_instance.background_down = 'path/to/tab_head/img_pressed'
+
+A TabbedPanelStrip contains the individual tab headers. To change the
+appearance of this tab strip, override the canvas of TabbedPanelStrip.
+For example, in the kv language:
+
+.. code-block:: kv
+
+    <TabbedPanelStrip>
+        canvas:
+            Color:
+                rgba: (0, 1, 0, 1) # green
+            Rectangle:
+                size: self.size
+                pos: self.pos
+
+By default the tabbed panel strip takes its background image and color from the
+tabbed panel's background_image and background_color.
+
+'''
+
+__all__ = ('StripLayout', 'TabbedPanel', 'TabbedPanelContent',
+           'TabbedPanelHeader', 'TabbedPanelItem', 'TabbedPanelStrip',
+           'TabbedPanelException')
+
+from functools import partial
+from kivy.clock import Clock
+from kivy.compat import string_types
+from kivy.factory import Factory
+from kivy.uix.togglebutton import ToggleButton
+from kivy.uix.widget import Widget
+from kivy.uix.scatter import Scatter
+from kivy.uix.scrollview import ScrollView
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.floatlayout import FloatLayout
+from kivy.logger import Logger
+from kivy.metrics import dp
+from kivy.properties import ObjectProperty, StringProperty, OptionProperty, \
+    ListProperty, NumericProperty, AliasProperty, BooleanProperty, \
+    ColorProperty
+
+
+class TabbedPanelException(Exception):
+    '''The TabbedPanelException class.
+    '''
+    pass
+
+
+class TabbedPanelHeader(ToggleButton):
+    '''A Base for implementing a Tabbed Panel Head. A button intended to be
+    used as a Heading/Tab for a TabbedPanel widget.
+
+    You can use this TabbedPanelHeader widget to add a new tab to a
+    TabbedPanel.
+    '''
+
+    content = ObjectProperty(None, allownone=True)
+    '''Content to be loaded when this tab header is selected.
+
+    :attr:`content` is an :class:`~kivy.properties.ObjectProperty` and defaults
+    to None.
+    '''
+
+    # only allow selecting the tab if not already selected
+    def on_touch_down(self, touch):
+        if self.state == 'down':
+            # dispatch to children, not to self
+            for child in self.children:
+                child.dispatch('on_touch_down', touch)
+            return
+        else:
+            super(TabbedPanelHeader, self).on_touch_down(touch)
+
+    def on_release(self, *largs):
+        # Tabbed panel header is a child of tab_strib which has a
+        # `tabbed_panel` property
+        if self.parent:
+            self.parent.tabbed_panel.switch_to(self)
+        else:
+            # tab removed before we could switch to it. Switch back to
+            # previous tab
+            self.panel.switch_to(self.panel.current_tab)
+
+
+class TabbedPanelItem(TabbedPanelHeader):
+    '''This is a convenience class that provides a header of type
+    TabbedPanelHeader and links it with the content automatically. Thus
+    facilitating you to simply do the following in kv language:
+
+    .. code-block:: kv
+
+        <TabbedPanel>:
+            # ...other settings
+            TabbedPanelItem:
+                BoxLayout:
+                    Label:
+                        text: 'Second tab content area'
+                    Button:
+                        text: 'Button that does nothing'
+
+    .. versionadded:: 1.5.0
+    '''
+
+    def add_widget(self, widget, *args, **kwargs):
+        self.content = widget
+        if not self.parent:
+            return
+        panel = self.parent.tabbed_panel
+        if panel.current_tab == self:
+            panel.switch_to(self)
+
+    def remove_widget(self, *args, **kwargs):
+        self.content = None
+        if not self.parent:
+            return
+        panel = self.parent.tabbed_panel
+        if panel.current_tab == self:
+            panel.remove_widget(*args, **kwargs)
+
+
+class TabbedPanelStrip(GridLayout):
+    '''A strip intended to be used as background for Heading/Tab.
+    This does not cover the blank areas in case the tabs don't cover
+    the entire width/height of the TabbedPanel(use :class:`StripLayout`
+    for that).
+    '''
+    tabbed_panel = ObjectProperty(None)
+    '''Link to the panel that the tab strip is a part of.
+
+    :attr:`tabbed_panel` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None .
+    '''
+
+
+class StripLayout(GridLayout):
+    ''' The main layout that is used to house the entire tabbedpanel strip
+    including the blank areas in case the tabs don't cover the entire
+    width/height.
+
+    .. versionadded:: 1.8.0
+
+    '''
+
+    border = ListProperty([4, 4, 4, 4])
+    '''Border property for the :attr:`background_image`.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and defaults
+    to [4, 4, 4, 4]
+    '''
+
+    background_image = StringProperty(
+        'atlas://data/images/defaulttheme/action_view')
+    '''Background image to be used for the Strip layout of the TabbedPanel.
+
+    :attr:`background_image` is a :class:`~kivy.properties.StringProperty` and
+    defaults to a transparent image.
+    '''
+
+
+class TabbedPanelContent(FloatLayout):
+    '''The TabbedPanelContent class.
+    '''
+    pass
+
+
+class TabbedPanel(GridLayout):
+    '''The TabbedPanel class. See module documentation for more information.
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''Background color, in the format (r, g, b, a).
+
+    :attr:`background_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    border = ListProperty([16, 16, 16, 16])
+    '''Border used for :class:`~kivy.graphics.vertex_instructions.BorderImage`
+    graphics instruction, used itself for :attr:`background_image`.
+    Can be changed for a custom background.
+
+    It must be a list of four values: (bottom, right, top, left). Read the
+    BorderImage instructions for more information.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and
+    defaults to (16, 16, 16, 16)
+    '''
+
+    background_image = StringProperty('atlas://data/images/defaulttheme/tab')
+    '''Background image of the main shared content object.
+
+    :attr:`background_image` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/tab'.
+    '''
+
+    background_disabled_image = StringProperty(
+        'atlas://data/images/defaulttheme/tab_disabled')
+    '''Background image of the main shared content object when disabled.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background_disabled_image` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/tab'.
+    '''
+
+    strip_image = StringProperty(
+        'atlas://data/images/defaulttheme/action_view')
+    '''Background image of the tabbed strip.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`strip_image` is a :class:`~kivy.properties.StringProperty`
+    and defaults to a empty image.
+    '''
+
+    strip_border = ListProperty([4, 4, 4, 4])
+    '''Border to be used on :attr:`strip_image`.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`strip_border` is a :class:`~kivy.properties.ListProperty` and
+    defaults to [4, 4, 4, 4].
+    '''
+
+    _current_tab = ObjectProperty(None)
+
+    def get_current_tab(self):
+        return self._current_tab
+
+    current_tab = AliasProperty(get_current_tab, None, bind=('_current_tab', ))
+    '''Links to the currently selected or active tab.
+
+    .. versionadded:: 1.4.0
+
+    :attr:`current_tab` is an :class:`~kivy.AliasProperty`, read-only.
+    '''
+
+    tab_pos = OptionProperty(
+        'top_left',
+        options=('left_top', 'left_mid', 'left_bottom', 'top_left',
+                 'top_mid', 'top_right', 'right_top', 'right_mid',
+                 'right_bottom', 'bottom_left', 'bottom_mid', 'bottom_right'))
+    '''Specifies the position of the tabs relative to the content.
+    Can be one of: `left_top`, `left_mid`, `left_bottom`, `top_left`,
+    `top_mid`, `top_right`, `right_top`, `right_mid`, `right_bottom`,
+    `bottom_left`, `bottom_mid`, `bottom_right`.
+
+    :attr:`tab_pos` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'top_left'.
+    '''
+
+    tab_height = NumericProperty('40dp')
+    '''Specifies the height of the tab header.
+
+    :attr:`tab_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 40.
+    '''
+
+    tab_width = NumericProperty('100dp', allownone=True)
+    '''Specifies the width of the tab header.
+
+    :attr:`tab_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 100.
+    '''
+
+    do_default_tab = BooleanProperty(True)
+    '''Specifies whether a default_tab head is provided.
+
+    .. versionadded:: 1.5.0
+
+    :attr:`do_default_tab` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to 'True'.
+    '''
+
+    default_tab_text = StringProperty('Default tab')
+    '''Specifies the text displayed on the default tab header.
+
+    :attr:`default_tab_text` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'default tab'.
+    '''
+
+    default_tab_cls = ObjectProperty(TabbedPanelHeader)
+    '''Specifies the class to use for the styling of the default tab.
+
+    .. versionadded:: 1.4.0
+
+    .. warning::
+        `default_tab_cls` should be subclassed from `TabbedPanelHeader`
+
+    :attr:`default_tab_cls` is an :class:`~kivy.properties.ObjectProperty`
+    and defaults to `TabbedPanelHeader`. If you set a string, the
+    :class:`~kivy.factory.Factory` will be used to resolve the class.
+
+    .. versionchanged:: 1.8.0
+        The :class:`~kivy.factory.Factory` will resolve the class if a string
+        is set.
+    '''
+
+    def get_tab_list(self):
+        if self._tab_strip:
+            return self._tab_strip.children
+        return 1.
+
+    tab_list = AliasProperty(get_tab_list, None)
+    '''List of all the tab headers.
+
+    :attr:`tab_list` is an :class:`~kivy.properties.AliasProperty` and is
+    read-only.
+    '''
+
+    content = ObjectProperty(None)
+    '''This is the object holding (current_tab's content is added to this)
+    the content of the current tab. To Listen to the changes in the content
+    of the current tab, you should bind to current_tabs `content` property.
+
+    :attr:`content` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to 'None'.
+    '''
+
+    _default_tab = ObjectProperty(None, allow_none=True)
+
+    def get_def_tab(self):
+        return self._default_tab
+
+    def set_def_tab(self, new_tab):
+        if not issubclass(new_tab.__class__, TabbedPanelHeader):
+            raise TabbedPanelException('`default_tab_class` should be\
+                subclassed from `TabbedPanelHeader`')
+        if self._default_tab == new_tab:
+            return
+        oltab = self._default_tab
+        self._default_tab = new_tab
+        self.remove_widget(oltab)
+        self._original_tab = None
+        self.switch_to(new_tab)
+        new_tab.state = 'down'
+
+    default_tab = AliasProperty(get_def_tab, set_def_tab,
+                                bind=('_default_tab', ))
+    '''Holds the default tab.
+
+    .. Note:: For convenience, the automatically provided default tab is
+              deleted when you change default_tab to something else.
+              As of 1.5.0, this behaviour has been extended to every
+              `default_tab` for consistency and not just the automatically
+              provided one.
+
+    :attr:`default_tab` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def get_def_tab_content(self):
+        return self.default_tab.content
+
+    def set_def_tab_content(self, *l):
+        self.default_tab.content = l[0]
+
+    default_tab_content = AliasProperty(get_def_tab_content,
+                                        set_def_tab_content)
+    '''Holds the default tab content.
+
+    :attr:`default_tab_content` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    _update_top_ev = _update_tab_ev = _update_tabs_ev = None
+
+    def __init__(self, **kwargs):
+        # these variables need to be initialized before the kv lang is
+        # processed setup the base layout for the tabbed panel
+        self._childrens = []
+        self._tab_layout = StripLayout(rows=1)
+        self.rows = 1
+        self._tab_strip = TabbedPanelStrip(
+            tabbed_panel=self,
+            rows=1, size_hint=(None, None),
+            height=self.tab_height, width=self.tab_width)
+
+        self._partial_update_scrollview = None
+        self.content = TabbedPanelContent()
+        self._current_tab = self._original_tab \
+            = self._default_tab = TabbedPanelHeader()
+
+        super(TabbedPanel, self).__init__(**kwargs)
+
+        self.fbind('size', self._reposition_tabs)
+        if not self.do_default_tab:
+            Clock.schedule_once(self._switch_to_first_tab)
+            return
+        self._setup_default_tab()
+        self.switch_to(self.default_tab)
+
+    def switch_to(self, header, do_scroll=False):
+        '''Switch to a specific panel header.
+
+        .. versionchanged:: 1.10.0
+
+        If used with `do_scroll=True`, it scrolls
+        to the header's tab too.
+
+        :meth:`switch_to` cannot be called from within the
+        :class:`TabbedPanel` or its subclass' ``__init__`` method.
+        If that is required, use the ``Clock`` to schedule it. See `discussion
+        <https://github.com/kivy/kivy/issues/3493#issuecomment-121567969>`_
+        for full example.
+        '''
+        header_content = header.content
+        self._current_tab.state = 'normal'
+        header.state = 'down'
+        self._current_tab = header
+        self.clear_widgets()
+        if header_content is None:
+            return
+        # if content has a previous parent remove it from that parent
+        parent = header_content.parent
+        if parent:
+            parent.remove_widget(header_content)
+        self.add_widget(header_content)
+
+        if do_scroll:
+            tabs = self._tab_strip
+            tabs.parent.scroll_to(header)
+
+    def clear_tabs(self, *l):
+        self_tabs = self._tab_strip
+        self_tabs.clear_widgets()
+        if self.do_default_tab:
+            self_default_tab = self._default_tab
+            self_tabs.add_widget(self_default_tab)
+            self_tabs.width = self_default_tab.width
+        self._reposition_tabs()
+
+    def add_widget(self, widget, *args, **kwargs):
+        content = self.content
+        if content is None:
+            return
+        parent = widget.parent
+        if parent:
+            parent.remove_widget(widget)
+        if widget in (content, self._tab_layout):
+            super(TabbedPanel, self).add_widget(widget, *args, **kwargs)
+        elif isinstance(widget, TabbedPanelHeader):
+            self_tabs = self._tab_strip
+            self_tabs.add_widget(widget, *args, **kwargs)
+            widget.group = '__tab%r__' % self_tabs.uid
+            self.on_tab_width()
+        else:
+            widget.pos_hint = {'x': 0, 'top': 1}
+            self._childrens.append(widget)
+            content.disabled = self.current_tab.disabled
+            content.add_widget(widget, *args, **kwargs)
+
+    def remove_widget(self, widget, *args, **kwargs):
+        content = self.content
+        if content is None:
+            return
+        if widget in (content, self._tab_layout):
+            super(TabbedPanel, self).remove_widget(widget, *args, **kwargs)
+        elif isinstance(widget, TabbedPanelHeader):
+            if not (self.do_default_tab and widget is self._default_tab):
+                self_tabs = self._tab_strip
+                self_tabs.width -= widget.width
+                self_tabs.remove_widget(widget)
+                if widget.state == 'down' and self.do_default_tab:
+                    self._default_tab.on_release()
+                self._reposition_tabs()
+            else:
+                Logger.info('TabbedPanel: default tab! can\'t be removed.\n' +
+                            'Change `default_tab` to a different tab.')
+        else:
+            if widget in self._childrens:
+                self._childrens.remove(widget)
+            if widget in content.children:
+                content.remove_widget(widget, *args, **kwargs)
+
+    def clear_widgets(self, *args, **kwargs):
+        if self.content:
+            self.content.clear_widgets(*args, **kwargs)
+
+    def on_strip_image(self, instance, value):
+        if not self._tab_layout:
+            return
+        self._tab_layout.background_image = value
+
+    def on_strip_border(self, instance, value):
+        if not self._tab_layout:
+            return
+        self._tab_layout.border = value
+
+    def on_do_default_tab(self, instance, value):
+        if not value:
+            dft = self.default_tab
+            if dft in self.tab_list:
+                self.remove_widget(dft)
+                self._switch_to_first_tab()
+                self._default_tab = self._current_tab
+        else:
+            self._current_tab.state = 'normal'
+            self._setup_default_tab()
+
+    def on_default_tab_text(self, *args):
+        self._default_tab.text = self.default_tab_text
+
+    def on_tab_width(self, *l):
+        ev = self._update_tab_ev
+        if ev is None:
+            ev = self._update_tab_ev = Clock.create_trigger(
+                self._update_tab_width, 0)
+        ev()
+
+    def on_tab_height(self, *l):
+        self._tab_layout.height = self._tab_strip.height = self.tab_height
+        self._reposition_tabs()
+
+    def on_tab_pos(self, *l):
+        # ensure canvas
+        self._reposition_tabs()
+
+    def _setup_default_tab(self):
+        if self._default_tab in self.tab_list:
+            return
+        content = self._default_tab.content
+        _tabs = self._tab_strip
+        cls = self.default_tab_cls
+
+        if isinstance(cls, string_types):
+            cls = Factory.get(cls)
+
+        if not issubclass(cls, TabbedPanelHeader):
+            raise TabbedPanelException('`default_tab_class` should be\
+                subclassed from `TabbedPanelHeader`')
+
+        # no need to instantiate if class is TabbedPanelHeader
+        if cls != TabbedPanelHeader:
+            self._current_tab = self._original_tab = self._default_tab = cls()
+
+        default_tab = self.default_tab
+        if self._original_tab == self.default_tab:
+            default_tab.text = self.default_tab_text
+
+        default_tab.height = self.tab_height
+        default_tab.group = '__tab%r__' % _tabs.uid
+        default_tab.state = 'down'
+        default_tab.width = self.tab_width if self.tab_width else 100
+        default_tab.content = content
+
+        tl = self.tab_list
+        if default_tab not in tl:
+            _tabs.add_widget(default_tab, len(tl))
+
+        if default_tab.content:
+            self.clear_widgets()
+            self.add_widget(self.default_tab.content)
+        else:
+            Clock.schedule_once(self._load_default_tab_content)
+        self._current_tab = default_tab
+
+    def _switch_to_first_tab(self, *l):
+        ltl = len(self.tab_list) - 1
+        if ltl > -1:
+            self._current_tab = dt = self._original_tab \
+                = self.tab_list[ltl]
+            self.switch_to(dt)
+
+    def _load_default_tab_content(self, dt):
+        if self.default_tab:
+            self.switch_to(self.default_tab)
+
+    def _reposition_tabs(self, *l):
+        ev = self._update_tabs_ev
+        if ev is None:
+            ev = self._update_tabs_ev = Clock.create_trigger(
+                self._update_tabs, 0)
+        ev()
+
+    def _update_tabs(self, *l):
+        self_content = self.content
+        if not self_content:
+            return
+        # cache variables for faster access
+        tab_pos = self.tab_pos
+        tab_layout = self._tab_layout
+        tab_layout.clear_widgets()
+        scrl_v = ScrollView(size_hint=(None, 1), always_overscroll=False)
+        tabs = self._tab_strip
+        parent = tabs.parent
+        if parent:
+            parent.remove_widget(tabs)
+        scrl_v.add_widget(tabs)
+        scrl_v.pos = (0, 0)
+        self_update_scrollview = self._update_scrollview
+
+        # update scrlv width when tab width changes depends on tab_pos
+        if self._partial_update_scrollview is not None:
+            tabs.unbind(width=self._partial_update_scrollview)
+        self._partial_update_scrollview = partial(
+            self_update_scrollview, scrl_v)
+        tabs.bind(width=self._partial_update_scrollview)
+
+        # remove all widgets from the tab_strip
+        super(TabbedPanel, self).clear_widgets()
+        tab_height = self.tab_height
+
+        widget_list = []
+        tab_list = []
+        pos_letter = tab_pos[0]
+        if pos_letter == 'b' or pos_letter == 't':
+            # bottom or top positions
+            # one col containing the tab_strip and the content
+            self.cols = 1
+            self.rows = 2
+            # tab_layout contains the scrollview containing tabs and two blank
+            # dummy widgets for spacing
+            tab_layout.rows = 1
+            tab_layout.cols = 3
+            tab_layout.size_hint = (1, None)
+            tab_layout.height = (tab_height + tab_layout.padding[1] +
+                                 tab_layout.padding[3] + dp(2))
+            self_update_scrollview(scrl_v)
+
+            if pos_letter == 'b':
+                # bottom
+                if tab_pos == 'bottom_mid':
+                    tab_list = (Widget(), scrl_v, Widget())
+                    widget_list = (self_content, tab_layout)
+                else:
+                    if tab_pos == 'bottom_left':
+                        tab_list = (scrl_v, Widget(), Widget())
+                    elif tab_pos == 'bottom_right':
+                        # add two dummy widgets
+                        tab_list = (Widget(), Widget(), scrl_v)
+                    widget_list = (self_content, tab_layout)
+            else:
+                # top
+                if tab_pos == 'top_mid':
+                    tab_list = (Widget(), scrl_v, Widget())
+                elif tab_pos == 'top_left':
+                    tab_list = (scrl_v, Widget(), Widget())
+                elif tab_pos == 'top_right':
+                    tab_list = (Widget(), Widget(), scrl_v)
+                widget_list = (tab_layout, self_content)
+        elif pos_letter == 'l' or pos_letter == 'r':
+            # left or right positions
+            # one row containing the tab_strip and the content
+            self.cols = 2
+            self.rows = 1
+            # tab_layout contains two blank dummy widgets for spacing
+            # "vertically" and the scatter containing scrollview
+            # containing tabs
+            tab_layout.rows = 3
+            tab_layout.cols = 1
+            tab_layout.size_hint = (None, 1)
+            tab_layout.width = tab_height
+            scrl_v.height = tab_height
+            self_update_scrollview(scrl_v)
+
+            # rotate the scatter for vertical positions
+            rotation = 90 if tab_pos[0] == 'l' else -90
+            sctr = Scatter(do_translation=False,
+                           rotation=rotation,
+                           do_rotation=False,
+                           do_scale=False,
+                           size_hint=(None, None),
+                           auto_bring_to_front=False,
+                           size=scrl_v.size)
+            sctr.add_widget(scrl_v)
+
+            lentab_pos = len(tab_pos)
+
+            # Update scatter's top when its pos changes.
+            # Needed for repositioning scatter to the correct place after its
+            # added to the parent. Use clock_schedule_once to ensure top is
+            # calculated after the parent's pos on canvas has been calculated.
+            # This is needed for when tab_pos changes to correctly position
+            # scatter. Without clock.schedule_once the positions would look
+            # fine but touch won't translate to the correct position
+
+            if tab_pos[lentab_pos - 4:] == '_top':
+                # on positions 'left_top' and 'right_top'
+                sctr.bind(pos=partial(self._update_top, sctr, 'top', None))
+                tab_list = (sctr, )
+            elif tab_pos[lentab_pos - 4:] == '_mid':
+                # calculate top of scatter
+                sctr.bind(pos=partial(self._update_top, sctr, 'mid',
+                                      scrl_v.width))
+                tab_list = (Widget(), sctr, Widget())
+            elif tab_pos[lentab_pos - 7:] == '_bottom':
+                tab_list = (Widget(), Widget(), sctr)
+
+            if pos_letter == 'l':
+                widget_list = (tab_layout, self_content)
+            else:
+                widget_list = (self_content, tab_layout)
+
+        # add widgets to tab_layout
+        add = tab_layout.add_widget
+        for widg in tab_list:
+            add(widg)
+
+        # add widgets to self
+        add = self.add_widget
+        for widg in widget_list:
+            add(widg)
+
+    def _update_tab_width(self, *l):
+        if self.tab_width:
+            for tab in self.tab_list:
+                tab.size_hint_x = 1
+            tsw = self.tab_width * len(self._tab_strip.children)
+        else:
+            # tab_width = None
+            tsw = 0
+            for tab in self.tab_list:
+                if tab.size_hint_x:
+                    # size_hint_x: x/.xyz
+                    tab.size_hint_x = 1
+                    # drop to default tab_width
+                    tsw += 100
+                else:
+                    # size_hint_x: None
+                    tsw += tab.width
+        self._tab_strip.width = tsw
+        self._reposition_tabs()
+
+    def _update_top(self, *args):
+        sctr, top, scrl_v_width, x, y = args
+        ev = self._update_top_ev
+        if ev is not None:
+            ev.cancel()
+
+        ev = self._update_top_ev = Clock.schedule_once(
+            partial(self._updt_top, sctr, top, scrl_v_width), 0)
+
+    def _updt_top(self, sctr, top, scrl_v_width, *args):
+        if top[0] == 't':
+            sctr.top = self.top
+        else:
+            sctr.top = self.top - (self.height - scrl_v_width) / 2
+
+    def _update_scrollview(self, scrl_v, *l):
+        self_tab_pos = self.tab_pos
+        self_tabs = self._tab_strip
+        if self_tab_pos[0] == 'b' or self_tab_pos[0] == 't':
+            # bottom or top
+            scrl_v.width = min(self.width, self_tabs.width)
+            # required for situations when scrl_v's pos is calculated
+            # when it has no parent
+            scrl_v.top += 1
+            scrl_v.top -= 1
+        else:
+            # left or right
+            scrl_v.width = min(self.height, self_tabs.width)
+            self_tabs.pos = (0, 0)
diff --git a/kivy/uix/textinput.py b/kivy/uix/textinput.py
new file mode 100644
index 0000000..e42f2ab
--- /dev/null
+++ b/kivy/uix/textinput.py
@@ -0,0 +1,3995 @@
+'''
+Text Input
+==========
+
+.. versionadded:: 1.0.4
+
+.. image:: images/textinput-mono.jpg
+.. image:: images/textinput-multi.jpg
+
+The :class:`TextInput` widget provides a box for editable plain text.
+
+Unicode, multiline, cursor navigation, selection and clipboard features
+are supported.
+
+The :class:`TextInput` uses two different coordinate systems:
+
+* (x, y) - coordinates in pixels, mostly used for rendering on screen.
+* (col, row) - cursor index in characters / lines, used for selection
+  and cursor movement.
+
+
+Usage example
+-------------
+
+To create a multiline :class:`TextInput` (the 'enter' key adds a new line)::
+
+    from kivy.uix.textinput import TextInput
+    textinput = TextInput(text='Hello world')
+
+To create a singleline :class:`TextInput`, set the :class:`TextInput.multiline`
+property to False (the 'enter' key will defocus the TextInput and emit an
+:meth:`TextInput.on_text_validate` event)::
+
+    def on_enter(instance, value):
+        print('User pressed enter in', instance)
+
+    textinput = TextInput(text='Hello world', multiline=False)
+    textinput.bind(on_text_validate=on_enter)
+
+The textinput's text is stored in its :attr:`TextInput.text` property. To run a
+callback when the text changes::
+
+    def on_text(instance, value):
+        print('The widget', instance, 'have:', value)
+
+    textinput = TextInput()
+    textinput.bind(text=on_text)
+
+You can set the :class:`focus <kivy.uix.behaviors.FocusBehavior>` to a
+Textinput, meaning that the input box will be highlighted and keyboard focus
+will be requested::
+
+    textinput = TextInput(focus=True)
+
+The textinput is defocused if the 'escape' key is pressed, or if another
+widget requests the keyboard. You can bind a callback to the focus property to
+get notified of focus changes::
+
+    def on_focus(instance, value):
+        if value:
+            print('User focused', instance)
+        else:
+            print('User defocused', instance)
+
+    textinput = TextInput()
+    textinput.bind(focus=on_focus)
+
+See :class:`~kivy.uix.behaviors.FocusBehavior`, from which the
+:class:`TextInput` inherits, for more details.
+
+
+Selection
+---------
+
+The selection is automatically updated when the cursor position changes.
+You can get the currently selected text from the
+:attr:`TextInput.selection_text` property.
+
+Filtering
+---------
+
+You can control which text can be added to the :class:`TextInput` by
+overwriting :meth:`TextInput.insert_text`. Every string that is typed, pasted
+or inserted by any other means into the :class:`TextInput` is passed through
+this function. By overwriting it you can reject or change unwanted characters.
+
+For example, to write only in capitalized characters::
+
+    class CapitalInput(TextInput):
+
+        def insert_text(self, substring, from_undo=False):
+            s = substring.upper()
+            return super().insert_text(s, from_undo=from_undo)
+
+Or to only allow floats (0 - 9 and a single period)::
+
+    class FloatInput(TextInput):
+
+        pat = re.compile('[^0-9]')
+        def insert_text(self, substring, from_undo=False):
+            pat = self.pat
+            if '.' in self.text:
+                s = re.sub(pat, '', substring)
+            else:
+                s = '.'.join(
+                    re.sub(pat, '', s)
+                    for s in substring.split('.', 1)
+                )
+            return super().insert_text(s, from_undo=from_undo)
+
+Default shortcuts
+-----------------
+
+=============== ========================================================
+   Shortcuts    Description
+--------------- --------------------------------------------------------
+Left            Move cursor to left
+Right           Move cursor to right
+Up              Move cursor to up
+Down            Move cursor to down
+Home            Move cursor at the beginning of the line
+End             Move cursor at the end of the line
+PageUp          Move cursor to 3 lines before
+PageDown        Move cursor to 3 lines after
+Backspace       Delete the selection or character before the cursor
+Del             Delete the selection of character after the cursor
+Shift + <dir>   Start a text selection. Dir can be Up, Down, Left or
+                Right
+Control + c     Copy selection
+Control + x     Cut selection
+Control + v     Paste clipboard content
+Control + a     Select all the content
+Control + z     undo
+Control + r     redo
+=============== ========================================================
+
+.. note::
+    To enable Emacs-style keyboard shortcuts, you can use
+    :class:`~kivy.uix.behaviors.emacs.EmacsBehavior`.
+
+'''
+
+
+import re
+import sys
+import math
+from os import environ
+from weakref import ref
+from itertools import chain, islice
+
+from kivy.animation import Animation
+from kivy.base import EventLoop
+from kivy.cache import Cache
+from kivy.clock import Clock
+from kivy.config import Config
+from kivy.core.window import Window
+from kivy.metrics import inch
+from kivy.utils import boundary, platform
+from kivy.uix.behaviors import FocusBehavior
+
+from kivy.core.text import Label, DEFAULT_FONT
+from kivy.graphics import Color, Rectangle, PushMatrix, PopMatrix, Callback
+from kivy.graphics.context_instructions import Transform
+from kivy.graphics.texture import Texture
+
+from kivy.uix.widget import Widget
+from kivy.uix.bubble import Bubble
+from kivy.uix.behaviors import ButtonBehavior
+from kivy.uix.image import Image
+
+from kivy.properties import StringProperty, NumericProperty, \
+    BooleanProperty, AliasProperty, OptionProperty, \
+    ListProperty, ObjectProperty, VariableListProperty, ColorProperty
+
+__all__ = ('TextInput', )
+
+
+if 'KIVY_DOC' in environ:
+    def triggered(*_, **__):
+        def decorator_func(func):
+            def decorated_func(*args, **kwargs):
+                return func(*args, **kwargs)
+            return decorated_func
+        return decorator_func
+else:
+    from kivy.clock import triggered
+
+
+Cache_register = Cache.register
+Cache_append = Cache.append
+Cache_get = Cache.get
+Cache_remove = Cache.remove
+Cache_register('textinput.label', timeout=60.)
+Cache_register('textinput.width', timeout=60.)
+
+FL_IS_LINEBREAK = 0x01
+FL_IS_WORDBREAK = 0x02
+FL_IS_NEWLINE = FL_IS_LINEBREAK | FL_IS_WORDBREAK
+
+# late binding
+Clipboard = None
+CutBuffer = None
+MarkupLabel = None
+_platform = platform
+
+# for reloading, we need to keep a list of textinput to retrigger the rendering
+_textinput_list = []
+
+# cache the result
+_is_osx = sys.platform == 'darwin'
+
+# When we are generating documentation, Config doesn't exist
+_is_desktop = False
+_scroll_timeout = _scroll_distance = 0
+if Config:
+    _is_desktop = Config.getboolean('kivy', 'desktop')
+    _scroll_timeout = Config.getint('widgets', 'scroll_timeout')
+    _scroll_distance = '{}sp'.format(Config.getint('widgets',
+                                                   'scroll_distance'))
+
+# register an observer to clear the textinput cache when OpenGL will reload
+if 'KIVY_DOC' not in environ:
+
+    def _textinput_clear_cache(*l):
+        Cache_remove('textinput.label')
+        Cache_remove('textinput.width')
+        for wr in _textinput_list[:]:
+            textinput = wr()
+            if textinput is None:
+                _textinput_list.remove(wr)
+            else:
+                textinput._trigger_refresh_text()
+                textinput._refresh_hint_text()
+
+    from kivy.graphics.context import get_context
+    get_context().add_reload_observer(_textinput_clear_cache, True)
+
+
+class Selector(ButtonBehavior, Image):
+    # Internal class for managing the selection Handles.
+
+    window = ObjectProperty()
+    target = ObjectProperty()
+    matrix = ObjectProperty()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.always_release = True
+        self.matrix = self.target.get_window_matrix()
+
+        with self.canvas.before:
+            Callback(self.update_transform)
+            PushMatrix()
+            self.transform = Transform()
+
+        with self.canvas.after:
+            PopMatrix()
+
+    def update_transform(self, cb):
+        matrix = self.target.get_window_matrix()
+        if self.matrix != matrix:
+            self.matrix = matrix
+            self.transform.identity()
+            self.transform.transform(self.matrix)
+
+    def transform_touch(self, touch):
+        matrix = self.matrix.inverse()
+        touch.apply_transform_2d(
+            lambda x, y: matrix.transform_point(x, y, 0)[:2]
+        )
+
+    def on_touch_down(self, touch):
+        if self.parent is not EventLoop.window:
+            return
+
+        try:
+            touch.push()
+            self.transform_touch(touch)
+            self._touch_diff = self.top - touch.y
+            if self.collide_point(*touch.pos):
+                FocusBehavior.ignored_touch.append(touch)
+            return super().on_touch_down(touch)
+        finally:
+            touch.pop()
+
+
+class TextInputCutCopyPaste(Bubble):
+    # Internal class used for showing the little bubble popup when
+    # copy/cut/paste happen.
+
+    textinput = ObjectProperty(None)
+    ''' Holds a reference to the TextInput this Bubble belongs to.
+    '''
+
+    but_cut = ObjectProperty(None)
+    but_copy = ObjectProperty(None)
+    but_paste = ObjectProperty(None)
+    but_selectall = ObjectProperty(None)
+
+    matrix = ObjectProperty(None)
+
+    _check_parent_ev = None
+
+    def __init__(self, **kwargs):
+        self.mode = 'normal'
+        super().__init__(**kwargs)
+        self._check_parent_ev = Clock.schedule_interval(self._check_parent, .5)
+        self.matrix = self.textinput.get_window_matrix()
+
+        with self.canvas.before:
+            Callback(self.update_transform)
+            PushMatrix()
+            self.transform = Transform()
+
+        with self.canvas.after:
+            PopMatrix()
+
+    def update_transform(self, cb):
+        m = self.textinput.get_window_matrix()
+        if self.matrix != m:
+            self.matrix = m
+            self.transform.identity()
+            self.transform.transform(self.matrix)
+
+    def transform_touch(self, touch):
+        matrix = self.matrix.inverse()
+        touch.apply_transform_2d(
+            lambda x, y: matrix.transform_point(x, y, 0)[:2])
+
+    def on_touch_down(self, touch):
+        try:
+            touch.push()
+            self.transform_touch(touch)
+            if self.collide_point(*touch.pos):
+                FocusBehavior.ignored_touch.append(touch)
+            return super().on_touch_down(touch)
+        finally:
+            touch.pop()
+
+    def on_touch_up(self, touch):
+        try:
+            touch.push()
+            self.transform_touch(touch)
+            for child in self.content.children:
+                if ref(child) in touch.grab_list:
+                    touch.grab_current = child
+                    break
+            return super().on_touch_up(touch)
+        finally:
+            touch.pop()
+
+    def on_textinput(self, instance, value):
+        global Clipboard
+        if value and not Clipboard and not _is_desktop:
+            value._ensure_clipboard()
+
+    def _check_parent(self, dt):
+        # this is a prevention to get the Bubble staying on the screen, if the
+        # attached textinput is not on the screen anymore.
+        parent = self.textinput
+        while parent is not None:
+            if parent == parent.parent:
+                break
+            parent = parent.parent
+        if parent is None:
+            self._check_parent_ev.cancel()
+            if self.textinput:
+                self.textinput._hide_cut_copy_paste()
+
+    def on_parent(self, instance, value):
+        parent = self.textinput
+        mode = self.mode
+
+        if parent:
+            self.clear_widgets()
+            if mode == 'paste':
+                # show only paste on long touch
+                self.but_selectall.opacity = 1
+                widget_list = [self.but_selectall, ]
+                if not parent.readonly:
+                    widget_list.append(self.but_paste)
+            elif parent.readonly:
+                # show only copy for read only text input
+                widget_list = (self.but_copy, )
+            else:
+                # normal mode
+                widget_list = (self.but_cut, self.but_copy, self.but_paste)
+
+            for widget in widget_list:
+                self.add_widget(widget)
+
+    def do(self, action):
+        textinput = self.textinput
+
+        if action == 'cut':
+            textinput._cut(textinput.selection_text)
+        elif action == 'copy':
+            textinput.copy()
+        elif action == 'paste':
+            textinput.paste()
+        elif action == 'selectall':
+            textinput.select_all()
+            self.mode = ''
+            anim = Animation(opacity=0, d=.333)
+            anim.bind(on_complete=lambda *args:
+                      self.on_parent(self, self.parent))
+            anim.start(self.but_selectall)
+            return
+
+        self.hide()
+
+    def hide(self):
+        parent = self.parent
+        if not parent:
+            return
+
+        anim = Animation(opacity=0, d=.225)
+        anim.bind(on_complete=lambda *args: parent.remove_widget(self))
+        anim.start(self)
+
+
+class TextInput(FocusBehavior, Widget):
+    '''TextInput class. See module documentation for more information.
+
+    :Events:
+        `on_text_validate`
+            Fired only in multiline=False mode when the user hits 'enter'.
+            This will also unfocus the textinput.
+        `on_double_tap`
+            Fired when a double tap happens in the text input. The default
+            behavior selects the text around the cursor position. More info at
+            :meth:`on_double_tap`.
+        `on_triple_tap`
+            Fired when a triple tap happens in the text input. The default
+            behavior selects the line around the cursor position. More info at
+            :meth:`on_triple_tap`.
+        `on_quad_touch`
+            Fired when four fingers are touching the text input. The default
+            behavior selects the whole text. More info at
+            :meth:`on_quad_touch`.
+
+    .. warning::
+        When changing a :class:`TextInput` property that requires re-drawing,
+        e.g. modifying the :attr:`text`, the updates occur on the next
+        clock cycle and not instantly. This might cause any changes to the
+        :class:`TextInput` that occur between the modification and the next
+        cycle to be ignored, or to use previous values. For example, after
+        a update to the :attr:`text`, changing the cursor in the same clock
+        frame will move it using the previous text and will likely end up in an
+        incorrect position. The solution is to schedule any updates to occur
+        on the next clock cycle using
+        :meth:`~kivy.clock.ClockBase.schedule_once`.
+
+    .. Note::
+        Selection is cancelled when TextInput is focused. If you need to
+        show selection when TextInput is focused, you should delay
+        (use Clock.schedule) the call to the functions for selecting
+        text (select_all, select_text).
+
+    .. versionchanged:: 1.10.0
+        `background_disabled_active` has been removed.
+
+    .. versionchanged:: 1.9.0
+
+        :class:`TextInput` now inherits from
+        :class:`~kivy.uix.behaviors.FocusBehavior`.
+        :attr:`~kivy.uix.behaviors.FocusBehavior.keyboard_mode`,
+        :meth:`~kivy.uix.behaviors.FocusBehavior.show_keyboard`,
+        :meth:`~kivy.uix.behaviors.FocusBehavior.hide_keyboard`,
+        :meth:`~kivy.uix.behaviors.FocusBehavior.focus`,
+        and :attr:`~kivy.uix.behaviors.FocusBehavior.input_type`
+        have been removed since they are now inherited
+        from :class:`~kivy.uix.behaviors.FocusBehavior`.
+
+    .. versionchanged:: 1.7.0
+        `on_double_tap`, `on_triple_tap` and `on_quad_touch` events added.
+
+    .. versionchanged:: 2.1.0
+        :attr:`~kivy.uix.behaviors.FocusBehavior.keyboard_suggestions`
+        is now inherited from :class:`~kivy.uix.behaviors.FocusBehavior`.
+    '''
+
+    __events__ = ('on_text_validate', 'on_double_tap', 'on_triple_tap',
+                  'on_quad_touch')
+
+    _resolved_base_dir = None
+
+    def __init__(self, **kwargs):
+        self._update_graphics_ev = Clock.create_trigger(
+            self._update_graphics, -1)
+        self.is_focusable = kwargs.get('is_focusable', True)
+        self._cursor = [0, 0]
+        self._selection = False
+        self._selection_finished = True
+        self._selection_touch = None
+        self.selection_text = u''
+        self._selection_from = None
+        self._selection_to = None
+        self._selection_callback = None
+        self._handle_left = None
+        self._handle_right = None
+        self._handle_middle = None
+        self._bubble = None
+        self._lines_flags = []
+        self._lines_labels = []
+        self._lines_rects = []
+        self._hint_text_flags = []
+        self._hint_text_labels = []
+        self._hint_text_rects = []
+        self._label_cached = None
+        self._line_options = None
+        self._keyboard_mode = Config.get('kivy', 'keyboard_mode')
+        self._command_mode = False
+        self._command = ''
+        self.reset_undo()
+        self._touch_count = 0
+        self._ctrl_l = False
+        self._ctrl_r = False
+        self._alt_l = False
+        self._alt_r = False
+        self._refresh_text_from_property_ev = None
+        self._long_touch_ev = None
+        self._do_blink_cursor_ev = Clock.create_trigger(
+            self._do_blink_cursor, .5, interval=True)
+        self._refresh_line_options_ev = None
+        self._scroll_distance_x = 0
+        self._scroll_distance_y = 0
+        self._enable_scroll = True
+        self._have_scrolled = False
+
+        # [from; to) range of lines being partially or fully rendered
+        # in TextInput's viewport
+        self._visible_lines_range = 0, 0
+
+        self.interesting_keys = {
+            8: 'backspace',
+            13: 'enter',
+            127: 'del',
+            271: 'enter',
+            273: 'cursor_up',
+            274: 'cursor_down',
+            275: 'cursor_right',
+            276: 'cursor_left',
+            278: 'cursor_home',
+            279: 'cursor_end',
+            280: 'cursor_pgup',
+            281: 'cursor_pgdown',
+            303: 'shift_L',
+            304: 'shift_R',
+            305: 'ctrl_L',
+            306: 'ctrl_R',
+            308: 'alt_L',
+            307: 'alt_R'
+        }
+
+        super().__init__(**kwargs)
+
+        fbind = self.fbind
+        refresh_line_options = self._trigger_refresh_line_options
+        update_text_options = self._update_text_options
+        trigger_update_graphics = self._trigger_update_graphics
+
+        fbind('font_size', refresh_line_options)
+        fbind('font_name', refresh_line_options)
+        fbind('font_context', refresh_line_options)
+        fbind('font_family', refresh_line_options)
+        fbind('base_direction', refresh_line_options)
+        fbind('text_language', refresh_line_options)
+
+        def handle_readonly(instance, value):
+            if value and (not _is_desktop or not self.allow_copy):
+                self.is_focusable = False
+            if (not (value or self.disabled) or _is_desktop and
+                    self._keyboard_mode == 'system'):
+                self._editable = True
+            else:
+                self._editable = False
+
+        fbind('padding', update_text_options)
+        fbind('tab_width', update_text_options)
+        fbind('font_size', update_text_options)
+        fbind('font_name', update_text_options)
+        fbind('size', update_text_options)
+        fbind('password', update_text_options)
+        fbind('password_mask', update_text_options)
+
+        fbind('pos', trigger_update_graphics)
+        fbind('halign', trigger_update_graphics)
+        fbind('readonly', handle_readonly)
+        fbind('focus', self._on_textinput_focused)
+        handle_readonly(self, self.readonly)
+
+        handles = self._trigger_position_handles = Clock.create_trigger(
+            self._position_handles)
+        self._trigger_show_handles = Clock.create_trigger(
+            self._show_handles, .05)
+        self._trigger_cursor_reset = Clock.create_trigger(
+            self._reset_cursor_blink)
+        self._trigger_update_cutbuffer = Clock.create_trigger(
+            self._update_cutbuffer)
+        refresh_line_options()
+        self._trigger_refresh_text()
+
+        fbind('pos', handles)
+        fbind('size', handles)
+
+        # when the gl context is reloaded, trigger the text rendering again.
+        _textinput_list.append(ref(self, TextInput._reload_remove_observer))
+
+        if platform == 'linux':
+            self._ensure_clipboard()
+
+    def on_text_validate(self):
+        pass
+
+    def cursor_index(self, cursor=None):
+        '''Return the cursor index in the text/value.
+        '''
+        if not cursor:
+            cursor = self.cursor
+        try:
+            lines = self._lines
+            if not lines:
+                return 0
+
+            flags = self._lines_flags
+            index, cursor_row = cursor
+
+            for _, line, flag in zip(
+                range(min(cursor_row, len(lines))),
+                lines,
+                flags
+            ):
+                index += len(line)
+                if flag & FL_IS_LINEBREAK:
+                    index += 1
+
+            if flags[cursor_row] & FL_IS_LINEBREAK:
+                index += 1
+            return index
+
+        except IndexError:
+            return 0
+
+    def cursor_offset(self):
+        '''Get the cursor x offset on the current line.
+        '''
+        offset = 0
+        row = int(self.cursor_row)
+        col = int(self.cursor_col)
+        lines = self._lines
+        if col and row < len(lines):
+            offset = self._get_text_width(
+                lines[row][:col],
+                self.tab_width,
+                self._label_cached
+            )
+        return offset
+
+    def get_cursor_from_index(self, index):
+        '''Return the (col, row) of the cursor from text index.
+        '''
+        index = boundary(index, 0, len(self.text))
+        if index <= 0:
+            return 0, 0
+        flags = self._lines_flags
+        lines = self._lines
+        if not lines:
+            return 0, 0
+
+        i = 0
+        for row, line in enumerate(lines):
+            count = i + len(line)
+            if flags[row] & FL_IS_LINEBREAK:
+                count += 1
+                i += 1
+            if count >= index:
+                return index - i, row
+            i = count
+        return int(index), int(row)
+
+    def select_text(self, start, end):
+        ''' Select a portion of text displayed in this TextInput.
+
+        .. versionadded:: 1.4.0
+
+        :Parameters:
+            `start`
+                Index of textinput.text from where to start selection
+            `end`
+                Index of textinput.text till which the selection should be
+                displayed
+        '''
+        if end < start:
+            raise Exception('end must be superior to start')
+        text_length = len(self.text)
+        self._selection_from = boundary(start, 0, text_length)
+        self._selection_to = boundary(end, 0, text_length)
+        self._selection_finished = True
+        self._update_selection(True)
+        self._update_graphics_selection()
+
+    def select_all(self):
+        ''' Select all of the text displayed in this TextInput.
+
+        .. versionadded:: 1.4.0
+        '''
+        self.select_text(0, len(self.text))
+
+    re_indent = re.compile(r'^(\s*|)')
+
+    def _auto_indent(self, substring):
+        index = self.cursor_index()
+        if index > 0:
+            _text = self.text
+            line_start = _text.rfind('\n', 0, index)
+            if line_start > -1:
+                line = _text[line_start + 1:index]
+                indent = self.re_indent.match(line).group()
+                substring += indent
+        return substring
+
+    def insert_text(self, substring, from_undo=False):
+        '''Insert new text at the current cursor position. Override this
+        function in order to pre-process text for input validation.
+        '''
+        _lines = self._lines
+        _lines_flags = self._lines_flags
+
+        if self.readonly or not substring or not self._lines:
+            return
+
+        if isinstance(substring, bytes):
+            substring = substring.decode('utf8')
+
+        if self.replace_crlf:
+            substring = substring.replace(u'\r\n', u'\n')
+
+        self._hide_handles(EventLoop.window)
+
+        if not from_undo and self.multiline and self.auto_indent \
+                and substring == u'\n':
+            substring = self._auto_indent(substring)
+
+        mode = self.input_filter
+        if mode not in (None, 'int', 'float'):
+            substring = mode(substring, from_undo)
+            if not substring:
+                return
+
+        col, row = self.cursor
+        cindex = self.cursor_index()
+        text = _lines[row]
+        len_str = len(substring)
+        new_text = text[:col] + substring + text[col:]
+        if mode is not None:
+            if mode == 'int':
+                if not re.match(self._insert_int_pat, new_text):
+                    return
+            elif mode == 'float':
+                if not re.match(self._insert_float_pat, new_text):
+                    return
+        self._set_line_text(row, new_text)
+
+        if len_str > 1 or substring == u'\n' or\
+            (substring == u' ' and _lines_flags[row] != FL_IS_LINEBREAK) or\
+            (row + 1 < len(_lines) and
+             _lines_flags[row + 1] != FL_IS_LINEBREAK) or\
+            (self._get_text_width(
+                new_text,
+                self.tab_width,
+                self._label_cached) > (self.width - self.padding[0] -
+                                       self.padding[2])):
+            # Avoid refreshing text on every keystroke.
+            # Allows for faster typing of text when the amount of text in
+            # TextInput gets large.
+
+            (
+                start, finish, lines, lines_flags, len_lines
+            ) = self._get_line_from_cursor(row, new_text)
+
+            # calling trigger here could lead to wrong cursor positioning
+            # and repeating of text when keys are added rapidly in a automated
+            # fashion. From Android Keyboard for example.
+            self._refresh_text_from_property(
+                'insert', start, finish, lines, lines_flags, len_lines
+            )
+
+        self.cursor = self.get_cursor_from_index(cindex + len_str)
+        # handle undo and redo
+        self._set_unredo_insert(cindex, cindex + len_str, substring, from_undo)
+
+    def _get_line_from_cursor(self, start, new_text, lines=None,
+                              lines_flags=None):
+        # get current paragraph from cursor position
+        if lines is None:
+            lines = self._lines
+        if lines_flags is None:
+            lines_flags = self._lines_flags
+        finish = start
+        _next = start + 1
+        if start > 0 and lines_flags[start] != FL_IS_LINEBREAK:
+            start -= 1
+            new_text = lines[start] + new_text
+        i = _next
+        for i in range(_next, len(lines_flags)):
+            if lines_flags[i] == FL_IS_LINEBREAK:
+                finish = i - 1
+                break
+        else:
+            finish = i
+
+        new_text = new_text + u''.join(lines[_next:finish + 1])
+        lines, lines_flags = self._split_smart(new_text)
+
+        len_lines = max(1, len(lines))
+        return start, finish, lines, lines_flags, len_lines
+
+    def _set_unredo_insert(self, ci, sci, substring, from_undo):
+        # handle undo and redo
+        if from_undo:
+            return
+        self._undo.append({
+            'undo_command': ('insert', ci, sci),
+            'redo_command': (ci, substring)
+        })
+        # reset redo when undo is appended to
+        self._redo = []
+
+    def reset_undo(self):
+        '''Reset undo and redo lists from memory.
+
+        .. versionadded:: 1.3.0
+
+        '''
+        self._redo = self._undo = []
+
+    def do_redo(self):
+        '''Do redo operation.
+
+        .. versionadded:: 1.3.0
+
+        This action re-does any command that has been un-done by
+        do_undo/ctrl+z. This function is automatically called when
+        `ctrl+r` keys are pressed.
+        '''
+        try:
+            x_item = self._redo.pop()
+            undo_type = x_item['undo_command'][0]
+            _get_cusror_from_index = self.get_cursor_from_index
+
+            if undo_type == 'insert':
+                cindex, substring = x_item['redo_command']
+                self.cursor = _get_cusror_from_index(cindex)
+                self.insert_text(substring, True)
+            elif undo_type == 'bkspc':
+                self.cursor = _get_cusror_from_index(x_item['redo_command'])
+                self.do_backspace(from_undo=True)
+            elif undo_type == 'shiftln':
+                direction, rows, cursor = x_item['redo_command'][1:]
+                self._shift_lines(direction, rows, cursor, True)
+            else:
+                # delsel
+                cindex, scindex = x_item['redo_command']
+                self._selection_from = cindex
+                self._selection_to = scindex
+                self._selection = True
+                self.delete_selection(True)
+                self.cursor = _get_cusror_from_index(cindex)
+            self._undo.append(x_item)
+        except IndexError:
+            # reached at top of undo list
+            pass
+
+    def do_undo(self):
+        '''Do undo operation.
+
+        .. versionadded:: 1.3.0
+
+        This action un-does any edits that have been made since the last
+        call to reset_undo().
+        This function is automatically called when `ctrl+z` keys are pressed.
+        '''
+        try:
+            x_item = self._undo.pop()
+            undo_type = x_item['undo_command'][0]
+            self.cursor = self.get_cursor_from_index(x_item['undo_command'][1])
+
+            if undo_type == 'insert':
+                cindex, scindex = x_item['undo_command'][1:]
+                self._selection_from = cindex
+                self._selection_to = scindex
+                self._selection = True
+                self.delete_selection(True)
+            elif undo_type == 'bkspc':
+                substring = x_item['undo_command'][2][0]
+                mode = x_item['undo_command'][3]
+                self.insert_text(substring, True)
+                if mode == 'del':
+                    self.cursor = self.get_cursor_from_index(
+                        self.cursor_index() - 1)
+            elif undo_type == 'shiftln':
+                direction, rows, cursor = x_item['undo_command'][1:]
+                self._shift_lines(direction, rows, cursor, True)
+            else:
+                # delsel
+                substring = x_item['undo_command'][2:][0]
+                self.insert_text(substring, True)
+            self._redo.append(x_item)
+        except IndexError:
+            # reached at top of undo list
+            pass
+
+    def do_backspace(self, from_undo=False, mode='bkspc'):
+        '''Do backspace operation from the current cursor position.
+        This action might do several things:
+
+            - removing the current selection if available.
+            - removing the previous char and move the cursor back.
+            - do nothing, if we are at the start.
+
+        '''
+        # IME system handles its own backspaces
+        if self.readonly or self._ime_composition:
+            return
+        col, row = self.cursor
+        _lines = self._lines
+        _lines_flags = self._lines_flags
+        text = _lines[row]
+        cursor_index = self.cursor_index()
+
+        if col == 0 and row == 0:
+            return
+        start = row
+        if col == 0:
+            if _lines_flags[row] == FL_IS_LINEBREAK:
+                substring = u'\n'
+                new_text = _lines[row - 1] + text
+            else:
+                substring = _lines[row - 1][-1] if len(_lines[row - 1]) > 0 \
+                    else u''
+                new_text = _lines[row - 1][:-1] + text
+            self._set_line_text(row - 1, new_text)
+            self._delete_line(row)
+            start = row - 1
+        else:
+            # ch = text[col-1]
+            substring = text[col - 1]
+            new_text = text[:col - 1] + text[col:]
+            self._set_line_text(row, new_text)
+
+        # refresh just the current line instead of the whole text
+        start, finish, lines, lineflags, len_lines = (
+            self._get_line_from_cursor(start, new_text)
+        )
+        # avoid trigger refresh, leads to issue with
+        # keys/text send rapidly through code.
+        self._refresh_text_from_property(
+            'insert' if col == 0 else 'del', start, finish,
+            lines, lineflags, len_lines
+        )
+
+        self.cursor = self.get_cursor_from_index(cursor_index - 1)
+        # handle undo and redo
+        self._set_unredo_bkspc(
+            cursor_index,
+            cursor_index - 1,
+            substring, from_undo, mode)
+
+    def _set_unredo_bkspc(self, ol_index, new_index, substring, from_undo,
+                          mode):
+        # handle undo and redo for backspace
+        if from_undo:
+            return
+        self._undo.append({
+            'undo_command': ('bkspc', new_index, substring, mode),
+            'redo_command': ol_index})
+        # reset redo when undo is appended to
+        self._redo = []
+
+    _re_whitespace = re.compile(r'\s+')
+
+    def _move_cursor_word_left(self, index=None):
+        pos = index or self.cursor_index()
+        if pos == 0:
+            return self.cursor
+        lines = self._lines
+        col, row = self.get_cursor_from_index(pos)
+        if col == 0:
+            row -= 1
+            col = len(lines[row])
+
+        while True:
+            matches = list(self._re_whitespace.finditer(lines[row], 0, col))
+            if not matches:
+                if col == 0:
+                    if row == 0:
+                        return 0, 0
+                    row -= 1
+                    col = len(lines[row])
+                    continue
+                return 0, row
+
+            match = matches[-1]
+            mpos = match.end()
+            if mpos == col:
+                if len(matches) > 1:
+                    match = matches[-2]
+                    mpos = match.end()
+                else:
+                    if match.start() == 0:
+                        if row == 0:
+                            return 0, 0
+                        row -= 1
+                        col = len(lines[row])
+                        continue
+                    return 0, row
+            col = mpos
+            return col, row
+
+    def _move_cursor_word_right(self, index=None):
+        pos = index or self.cursor_index()
+        col, row = self.get_cursor_from_index(pos)
+        lines = self._lines
+        mrow = len(lines) - 1
+        if row == mrow and col == len(lines[row]):
+            return col, row
+        if col == len(lines[row]):
+            row += 1
+            col = 0
+
+        while True:
+            matches = list(self._re_whitespace.finditer(lines[row], col))
+            if not matches:
+                if col == len(lines[row]):
+                    if row == mrow:
+                        return col, row
+                    row += 1
+                    col = 0
+                    continue
+                return len(lines[row]), row
+
+            match = matches[0]
+            mpos = match.start()
+            if mpos == col:
+                if len(matches) > 1:
+                    match = matches[1]
+                    mpos = match.start()
+                else:
+                    if match.end() == len(lines[row]):
+                        if row == mrow:
+                            return col, row
+                        row += 1
+                        col = 0
+                        continue
+                    return len(lines[row]), row
+            col = mpos
+            return col, row
+
+    def _expand_range(self, ifrom, ito=None):
+        if ito is None:
+            ito = ifrom
+        rfrom = self.get_cursor_from_index(ifrom)[1]
+        rtcol, rto = self.get_cursor_from_index(ito)
+        rfrom, rto = self._expand_rows(rfrom, rto + 1 if rtcol else rto)
+
+        return (self.cursor_index((0, rfrom)),
+                self.cursor_index((0, rto)))
+
+    def _expand_rows(self, rfrom, rto=None):
+        if rto is None or rto == rfrom:
+            rto = rfrom + 1
+        lines = self._lines
+        flags = list(reversed(self._lines_flags))
+        while rfrom > 0 and not (flags[rfrom - 1] & FL_IS_NEWLINE):
+            rfrom -= 1
+        rmax = len(lines) - 1
+        while 0 < rto < rmax and not (flags[rto - 1] & FL_IS_NEWLINE):
+            rto += 1
+        return max(0, rfrom), min(rmax, rto)
+
+    def _shift_lines(
+        self, direction, rows=None, old_cursor=None, from_undo=False
+    ):
+        if self._selection_callback:
+            if from_undo:
+                self._selection_callback.cancel()
+            else:
+                return
+
+        lines = self._lines
+        flags = list(reversed(self._lines_flags))
+        labels = self._lines_labels
+        rects = self._lines_rects
+        orig_cursor = self.cursor
+        sel = None
+        if old_cursor is not None:
+            self.cursor = old_cursor
+
+        if not rows:
+            sindex = self.selection_from
+            eindex = self.selection_to
+            if (sindex or eindex) and sindex != eindex:
+                sindex, eindex = tuple(sorted((sindex, eindex)))
+                sindex, eindex = self._expand_range(sindex, eindex)
+            else:
+                sindex, eindex = self._expand_range(self.cursor_index())
+            srow = self.get_cursor_from_index(sindex)[1]
+            erow = self.get_cursor_from_index(eindex)[1]
+            sel = sindex, eindex
+
+            if direction < 0 and srow > 0:
+                psrow, perow = self._expand_rows(srow - 1)
+                rows = ((srow, erow), (psrow, perow))
+            elif direction > 0 and erow < len(lines) - 1:
+                psrow, perow = self._expand_rows(erow)
+                rows = ((srow, erow), (psrow, perow))
+
+        else:
+            (srow, erow), (psrow, perow) = rows
+            if direction < 0:
+                m1srow, m1erow = psrow, perow
+                m2srow, m2erow = srow, erow
+                cdiff = psrow - perow
+                xdiff = srow - erow
+            else:
+                m1srow, m1erow = srow, erow
+                m2srow, m2erow = psrow, perow
+                cdiff = perow - psrow
+                xdiff = erow - srow
+
+            self._lines_flags = list(reversed(chain(
+                flags[:m1srow],
+                flags[m2srow:m2erow],
+                flags[m1srow:m1erow],
+                flags[m2erow:],
+            )))
+            self._lines[:] = (
+                lines[:m1srow]
+                + lines[m2srow:m2erow]
+                + lines[m1srow:m1erow]
+                + lines[m2erow:]
+            )
+            self._lines_labels = (
+                labels[:m1srow]
+                + labels[m2srow:m2erow]
+                + labels[m1srow:m1erow]
+                + labels[m2erow:]
+            )
+            self._lines_rects = (
+                rects[:m1srow]
+                + rects[m2srow:m2erow]
+                + rects[m1srow:m1erow]
+                + rects[m2erow:]
+            )
+            self._trigger_update_graphics()
+            csrow = srow + cdiff
+            cerow = erow + cdiff
+            sel = (
+                self.cursor_index((0, csrow)),
+                self.cursor_index((0, cerow))
+            )
+            self.cursor = self.cursor_col, self.cursor_row + cdiff
+
+            if not from_undo:
+                undo_rows = ((srow + cdiff, erow + cdiff),
+                             (psrow - xdiff, perow - xdiff))
+                self._undo.append({
+                    'undo_command': ('shiftln', direction * -1, undo_rows,
+                                     self.cursor),
+                    'redo_command': ('shiftln', direction, rows, orig_cursor),
+                })
+                self._redo = []
+
+        if sel:
+            def cb(dt):
+                self.select_text(*sel)
+                self._selection_callback = None
+            self._selection_callback = Clock.schedule_once(cb)
+
+    @property
+    def pgmove_speed(self):
+        """how much vertical distance hitting pg_up or pg_down will move
+        """
+        return int(
+            self.height
+            / (self.line_height + self.line_spacing) - 1
+        )
+
+    def _move_cursor_up(self, col, row, control=False, alt=False):
+        if self.multiline and control:
+            self.scroll_y = max(0, self.scroll_y - self.line_height)
+        elif not self.readonly and self.multiline and alt:
+            self._shift_lines(-1)
+            return
+        else:
+            row = max(row - 1, 0)
+            col = min(len(self._lines[row]), col)
+
+        return col, row
+
+    def _move_cursor_down(self, col, row, control, alt):
+        if self.multiline and control:
+            maxy = self.minimum_height - self.height
+            self.scroll_y = max(
+                0,
+                min(maxy, self.scroll_y + self.line_height)
+            )
+        elif not self.readonly and self.multiline and alt:
+            self._shift_lines(1)
+            return
+        else:
+            row = min(row + 1, len(self._lines) - 1)
+            col = min(len(self._lines[row]), col)
+
+        return col, row
+
+    def do_cursor_movement(self, action, control=False, alt=False):
+        '''Move the cursor relative to its current position.
+        Action can be one of :
+
+            - cursor_left: move the cursor to the left
+            - cursor_right: move the cursor to the right
+            - cursor_up: move the cursor on the previous line
+            - cursor_down: move the cursor on the next line
+            - cursor_home: move the cursor at the start of the current line
+            - cursor_end: move the cursor at the end of current line
+            - cursor_pgup: move one "page" before
+            - cursor_pgdown: move one "page" after
+
+        In addition, the behavior of certain actions can be modified:
+
+            - control + cursor_left: move the cursor one word to the left
+            - control + cursor_right: move the cursor one word to the right
+            - control + cursor_up: scroll up one line
+            - control + cursor_down: scroll down one line
+            - control + cursor_home: go to beginning of text
+            - control + cursor_end: go to end of text
+            - alt + cursor_up: shift line(s) up
+            - alt + cursor_down: shift line(s) down
+
+        .. versionchanged:: 1.9.1
+
+        '''
+        if not self._lines:
+            return
+
+        col, row = self.cursor
+        if action == 'cursor_up':
+            result = self._move_cursor_up(col, row, control, alt)
+            if result:
+                col, row = result
+            else:
+                return
+
+        elif action == 'cursor_down':
+            result = self._move_cursor_down(col, row, control, alt)
+            if result:
+                col, row = result
+            else:
+                return
+
+        elif action == 'cursor_home':
+            col = 0
+            if control:
+                row = 0
+
+        elif action == 'cursor_end':
+            if control:
+                row = len(self._lines) - 1
+            col = len(self._lines[row])
+
+        elif action == 'cursor_pgup':
+            row = max(0, row - self.pgmove_speed)
+            col = min(len(self._lines[row]), col)
+
+        elif action == 'cursor_pgdown':
+            row = min(row + self.pgmove_speed, len(self._lines) - 1)
+            col = min(len(self._lines[row]), col)
+
+        elif (
+            self._selection and self._selection_finished
+            and self._selection_from < self._selection_to
+            and action == 'cursor_left'
+        ):
+            current_selection_to = self._selection_to
+            while self._selection_from != current_selection_to:
+                current_selection_to -= 1
+                if col:
+                    col -= 1
+                else:
+                    row -= 1
+                    col = len(self._lines[row])
+
+        elif (
+            self._selection and self._selection_finished
+            and self._selection_from > self._selection_to
+            and action == 'cursor_right'
+        ):
+            current_selection_to = self._selection_to
+            while self._selection_from != current_selection_to:
+                current_selection_to += 1
+                if len(self._lines[row]) > col:
+                    col += 1
+                else:
+                    row += 1
+                    col = 0
+
+        elif action == 'cursor_left':
+            if not self.password and control:
+                col, row = self._move_cursor_word_left()
+            else:
+                if col == 0:
+                    if row:
+                        row -= 1
+                        col = len(self._lines[row])
+                else:
+                    col, row = col - 1, row
+
+        elif action == 'cursor_right':
+            if not self.password and control:
+                col, row = self._move_cursor_word_right()
+            else:
+                if col == len(self._lines[row]):
+                    if row < len(self._lines) - 1:
+                        col = 0
+                        row += 1
+                else:
+                    col, row = col + 1, row
+
+        dont_move_cursor = control and action in ['cursor_up', 'cursor_down']
+        if dont_move_cursor:
+            self._trigger_update_graphics()
+        else:
+            self.cursor = col, row
+
+    def get_cursor_from_xy(self, x, y):
+        '''Return the (col, row) of the cursor from an (x, y) position.
+        '''
+        padding_left, padding_top, padding_right, padding_bottom = self.padding
+
+        lines = self._lines
+        dy = self.line_height + self.line_spacing
+        cursor_x = x - self.x
+        scroll_y = self.scroll_y
+        scroll_x = self.scroll_x
+        scroll_y = scroll_y / dy if scroll_y > 0 else 0
+
+        cursor_y = (self.top - padding_top + scroll_y * dy) - y
+        cursor_y = int(boundary(
+            round(cursor_y / dy - 0.5),
+            0,
+            len(lines) - 1
+        ))
+
+        get_text_width = self._get_text_width
+        tab_width = self.tab_width
+        label_cached = self._label_cached
+
+        # Offset for horizontal text alignment
+        xoff = 0
+        halign = self.halign
+        base_dir = self.base_direction or self._resolved_base_dir
+        auto_halign_r = halign == 'auto' and base_dir and 'rtl' in base_dir
+
+        if halign == 'center':
+            viewport_width = self.width - padding_left - padding_right
+            xoff = max(
+                0, int((viewport_width - self._get_row_width(cursor_y)) / 2)
+            )
+
+        elif halign == 'right' or auto_halign_r:
+            viewport_width = self.width - padding_left - padding_right
+            xoff = max(
+                0, int(viewport_width - self._get_row_width(cursor_y))
+            )
+
+        for i in range(0, len(lines[cursor_y])):
+            line_y = lines[cursor_y]
+
+            if cursor_x + scroll_x < (
+                xoff
+                + get_text_width(line_y[:i], tab_width, label_cached)
+                + get_text_width(line_y[i], tab_width, label_cached) * 0.6
+                + padding_left
+            ):
+                cursor_x = i
+                break
+
+        return int(cursor_x), int(cursor_y)
+
+    #
+    # Selection control
+    #
+    def cancel_selection(self):
+        '''Cancel current selection (if any).
+        '''
+        self._selection_from = self._selection_to = self.cursor_index()
+        self._selection = False
+        self._selection_finished = True
+        self._selection_touch = None
+        self.selection_text = u''
+        self._trigger_update_graphics()
+
+    def delete_selection(self, from_undo=False):
+        '''Delete the current text selection (if any).
+        '''
+        if self.readonly:
+            return
+        self._hide_handles(EventLoop.window)
+        scroll_x = self.scroll_x
+        scroll_y = self.scroll_y
+        cc, cr = self.cursor
+        if not self._selection:
+            return
+        text = self.text
+        a, b = sorted((self._selection_from, self._selection_to))
+
+        start = self.get_cursor_from_index(a)
+        finish = self.get_cursor_from_index(b)
+        cur_line = self._lines[start[1]][:start[0]] +\
+            self._lines[finish[1]][finish[0]:]
+
+        self._set_line_text(start[1], cur_line)
+        start_del, finish_del, lines, lines_flags, len_lines = \
+            self._get_line_from_cursor(start[1], cur_line,
+                                       lines=(self._lines[:(start[1] + 1)] +
+                                              self._lines[(finish[1] + 1):]),
+                                       lines_flags=(
+                                           self._lines_flags[:(start[1] + 1)] +
+                                           self._lines_flags[(finish[1] + 1):])
+                                       )
+        self._refresh_text_from_property('del', start_del,
+                                         finish_del + (finish[1] - start[1]),
+                                         lines, lines_flags, len_lines)
+
+        self.scroll_x = scroll_x
+        self.scroll_y = scroll_y
+        # handle undo and redo for delete selection
+        self._set_unredo_delsel(a, b, text[a:b], from_undo)
+        self.cancel_selection()
+        self.cursor = self.get_cursor_from_index(a)
+
+    def _set_unredo_delsel(self, a, b, substring, from_undo):
+        # handle undo and redo for backspace
+        if from_undo:
+            return
+
+        self._undo.append({
+            'undo_command': ('delsel', a, substring),
+            'redo_command': (a, b)})
+        # reset redo when undo is appended to
+        self._redo = []
+
+    def _update_selection(self, finished=False):
+        '''Update selection text and order of from/to if finished is True.
+        Can be called multiple times until finished is True.
+        '''
+        a, b = int(self._selection_from), int(self._selection_to)
+        if a > b:
+            a, b = b, a
+        self._selection_finished = finished
+        _selection_text = self.text[a:b]
+        self.selection_text = ("" if not self.allow_copy else
+                               ((self.password_mask * (b - a)) if
+                                self.password else _selection_text))
+        if not finished:
+            self._selection = True
+        else:
+            self._selection = bool(len(_selection_text))
+            self._selection_touch = None
+        if a == 0:
+            # update graphics only on new line
+            # allows smoother scrolling, noticeably
+            # faster when dealing with large text.
+            self._update_graphics_selection()
+            # self._trigger_update_graphics()
+
+    #
+    # Touch control
+    #
+    def long_touch(self, dt):
+        self._long_touch_ev = None
+        if self._selection_to == self._selection_from:
+            pos = self.to_local(*self._touch_down.pos, relative=False)
+            self._show_cut_copy_paste(
+                pos, EventLoop.window, mode='paste')
+
+    def cancel_long_touch_event(self):
+        # schedule long touch for paste
+        if self._long_touch_ev is not None:
+            self._long_touch_ev.cancel()
+            self._long_touch_ev = None
+
+    def _select_word(self, delimiters=u' .,:;!?\'"<>()[]{}'):
+        cindex = self.cursor_index()
+        col = self.cursor_col
+        line = self._lines[self.cursor_row]
+        start = max(0, len(line[:col]) -
+                    max(line[:col].rfind(s) for s in delimiters) - 1)
+        end = min((line[col:].find(s) if line[col:].find(s) > -1
+                   else (len(line) - col)) for s in delimiters)
+        Clock.schedule_once(lambda dt: self.select_text(cindex - start,
+                                                        cindex + end))
+
+    def on_double_tap(self):
+        '''This event is dispatched when a double tap happens
+        inside TextInput. The default behavior is to select the
+        word around the current cursor position. Override this to provide
+        different behavior. Alternatively, you can bind to this
+        event to provide additional functionality.
+        '''
+        self._select_word()
+
+    def on_triple_tap(self):
+        '''This event is dispatched when a triple tap happens
+        inside TextInput. The default behavior is to select the
+        line around current cursor position. Override this to provide
+        different behavior. Alternatively, you can bind to this
+        event to provide additional functionality.
+        '''
+        ci = self.cursor_index()
+        sindex, eindex = self._expand_range(ci)
+        Clock.schedule_once(lambda dt: self.select_text(sindex, eindex))
+
+    def on_quad_touch(self):
+        '''This event is dispatched when four fingers are touching
+        inside TextInput. The default behavior is to select all text.
+        Override this to provide different behavior. Alternatively,
+        you can bind to this event to provide additional functionality.
+        '''
+        Clock.schedule_once(lambda dt: self.select_all())
+
+    def on_touch_down(self, touch):
+        if self.disabled:
+            return
+
+        touch_pos = touch.pos
+        if not self.collide_point(*touch_pos):
+            return False
+        if super().on_touch_down(touch):
+            return True
+
+        if self.focus:
+            self._trigger_cursor_reset()
+
+        # Check for scroll wheel
+        if 'button' in touch.profile and touch.button.startswith('scroll'):
+            # TODO: implement 'scrollleft' and 'scrollright'
+            scroll_type = touch.button[6:]
+            if scroll_type == 'down':
+                if self.multiline:
+                    if self.scroll_y > 0:
+                        self.scroll_y = max(0, self.scroll_y -
+                                            self.line_height)
+                        self._trigger_update_graphics()
+                else:
+                    if self.scroll_x > 0:
+                        self.scroll_x = max(0, self.scroll_x -
+                                            self.line_height)
+                        self._trigger_update_graphics()
+            if scroll_type == 'up':
+                if self.multiline:
+                    max_scroll_y = max(0, self.minimum_height - self.height)
+                    if self.scroll_y < max_scroll_y:
+                        self.scroll_y = min(max_scroll_y, self.scroll_y +
+                                            self.line_height)
+                        self._trigger_update_graphics()
+                else:
+                    minimum_width = (self._get_row_width(0) + self.padding[0] +
+                                     self.padding[2])
+                    max_scroll_x = max(0, minimum_width - self.width)
+                    if self.scroll_x < max_scroll_x:
+                        self.scroll_x = min(max_scroll_x, self.scroll_x +
+                                            self.line_height)
+                        self._trigger_update_graphics()
+            return True
+
+        touch.grab(self)
+        self._touch_count += 1
+        if touch.is_double_tap:
+            self.dispatch('on_double_tap')
+        if touch.is_triple_tap:
+            self.dispatch('on_triple_tap')
+        if self._touch_count == 4:
+            self.dispatch('on_quad_touch')
+
+        # stores the touch for later use
+        self._touch_down = touch
+
+        # Is a new touch_down, so previous scroll states needs to be reset
+        self._enable_scroll = True
+        self._have_scrolled = False
+        self._scroll_distance_x = 0
+        self._scroll_distance_y = 0
+
+        self._hide_cut_copy_paste(EventLoop.window)
+        # schedule long touch for paste
+        self._long_touch_ev = Clock.schedule_once(self.long_touch, .5)
+
+        self.cursor = self.get_cursor_from_xy(*touch_pos)
+        if not self.scroll_from_swipe:
+            self._cancel_update_selection(self._touch_down)
+
+        if CutBuffer and 'button' in touch.profile and \
+                touch.button == 'middle':
+            self.insert_text(CutBuffer.get_cutbuffer())
+            return True
+
+        return True
+
+    # cancel/update existing selection after a single tap
+    def _cancel_update_selection(self, touch):
+        if not self._selection_touch:
+            self.cancel_selection()
+            self._selection_touch = touch
+            self._selection_from = self._selection_to = self.cursor_index()
+            self._update_selection()
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is not self:
+            return
+        if not self.focus:
+            touch.ungrab(self)
+            if self._selection_touch is touch:
+                self._selection_touch = None
+            return False
+
+        if self.scroll_from_swipe:
+            self.scroll_text_from_swipe(touch)
+
+        if not self._have_scrolled and self._selection_touch is touch:
+            self.cursor = self.get_cursor_from_xy(touch.x, touch.y)
+            self._selection_to = self.cursor_index()
+            self._update_selection()
+            return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+        self._touch_count -= 1
+
+        self.cancel_long_touch_event()
+
+        if not self.focus:
+            return False
+
+        # types of touch that will have higher priority in being recognized,
+        # compared to single tap
+        prioritized_touch_types = (
+            touch.is_double_tap
+            or touch.is_triple_tap
+            or self._touch_count == 4
+        )
+
+        if not self._have_scrolled and not prioritized_touch_types:
+            # Is a single tap and did not scrolled.
+            # Selection needs to be canceled.
+            self._cancel_update_selection(self._touch_down)
+
+        # show Bubble
+        win = EventLoop.window
+        if self._selection_to != self._selection_from:
+            self._show_cut_copy_paste(touch.pos, win)
+
+        if self._selection_touch is touch:
+            self._selection_to = self.cursor_index()
+            self._update_selection(True)
+            if self.use_handles and self._selection_to == self._selection_from:
+                self._hide_handles()
+                handle_middle = self._handle_middle
+                if handle_middle is None:
+                    self._handle_middle = handle_middle = Selector(
+                        source=self.handle_image_middle,
+                        window=win,
+                        target=self,
+                        size_hint=(None, None),
+                        size=('45dp', '45dp'))
+                    handle_middle.bind(on_press=self._handle_pressed,
+                                       on_touch_move=self._handle_move,
+                                       on_release=self._handle_released)
+                if not self._handle_middle.parent and self.text:
+                    EventLoop.window.add_widget(handle_middle, canvas='after')
+                self._position_handles(mode='middle')
+            return True
+
+    def scroll_text_from_swipe(self, touch):
+        _scroll_timeout = (touch.time_update - touch.time_start) * 1000
+        self._scroll_distance_x += abs(touch.dx)
+        self._scroll_distance_y += abs(touch.dy)
+        if not self._have_scrolled:
+            # To be considered a scroll, touch should travel more than
+            # scroll_distance in less than the scroll_timeout since touch_down
+            if not (
+                _scroll_timeout <= self.scroll_timeout
+                and (
+                    (self._scroll_distance_x >= self.scroll_distance)
+                    or (self._scroll_distance_y >= self.scroll_distance)
+                )
+            ):
+                # Distance isn't enough (yet) to consider it as a scroll
+                if _scroll_timeout <= self.scroll_timeout:
+                    # Timeout is not reached, scroll is still enabled.
+                    return False
+                else:
+                    self._enable_scroll = False
+                    self._cancel_update_selection(self._touch_down)
+                    return False
+            # We have a scroll!
+            self._have_scrolled = True
+
+        self.cancel_long_touch_event()
+
+        if self.multiline:
+            max_scroll_y = max(0, self.minimum_height - self.height)
+            self.scroll_y = min(
+                max(0, self.scroll_y + touch.dy),
+                max_scroll_y
+            )
+        else:
+            minimum_width = (
+                self._get_row_width(0)
+                + self.padding[0] + self.padding[2]
+            )
+            max_scroll_x = max(0, minimum_width - self.width)
+            self.scroll_x = min(
+                max(0, self.scroll_x - touch.dx),
+                max_scroll_x
+            )
+        self._trigger_update_graphics()
+        self._position_handles()
+        return True
+
+    def _handle_pressed(self, instance):
+        self._hide_cut_copy_paste()
+        from_, to_ = self._selection_from, self.selection_to
+        if from_ > to_:
+            self._selection_from, self._selection_to = to_, from_
+
+    def _handle_released(self, instance):
+        if self._selection_from == self.selection_to:
+            return
+
+        self._update_selection()
+        self._show_cut_copy_paste(
+            (
+                self.x + instance.right
+                if instance is self._handle_left
+                else self.x + instance.x,
+                self.y + instance.top + self.line_height
+            ),
+            EventLoop.window
+        )
+
+    def _handle_move(self, instance, touch):
+        if touch.grab_current != instance:
+            return
+        get_cursor = self.get_cursor_from_xy
+        handle_right = self._handle_right
+        handle_left = self._handle_left
+        handle_middle = self._handle_middle
+
+        try:
+            touch.push()
+            touch.apply_transform_2d(self.to_widget)
+            x, y = touch.pos
+        finally:
+            touch.pop()
+
+        cursor = get_cursor(
+            x,
+            y + instance._touch_diff + (self.line_height / 2)
+        )
+        self.cursor = cursor
+
+        if instance != touch.grab_current:
+            return
+
+        if instance == handle_middle:
+            self._position_handles(mode='middle')
+            return
+
+        cindex = self.cursor_index()
+
+        if instance == handle_left:
+            self._selection_from = cindex
+        elif instance == handle_right:
+            self._selection_to = cindex
+        self._update_selection()
+        self._trigger_update_graphics()
+        self._trigger_position_handles()
+
+    def _position_handles(self, *args, **kwargs):
+        if not self.text:
+            return
+        mode = kwargs.get('mode', 'both')
+
+        lh = self.line_height
+
+        handle_middle = self._handle_middle
+        if handle_middle:
+            hp_mid = self.cursor_pos
+            pos = self.to_local(*hp_mid, relative=True)
+            handle_middle.x = pos[0] - handle_middle.width / 2
+            handle_middle.top = max(self.padding[3],
+                                    min(self.height - self.padding[1],
+                                        pos[1] - lh))
+        if mode[0] == 'm':
+            return
+
+        group = self.canvas.get_group('selection')
+        if not group:
+            return
+
+        EventLoop.window.remove_widget(self._handle_middle)
+
+        handle_left = self._handle_left
+        if not handle_left:
+            return
+        hp_left = group[2].pos
+        handle_left.pos = self.to_local(*hp_left, relative=True)
+        handle_left.x -= handle_left.width
+        handle_left.y -= handle_left.height
+
+        handle_right = self._handle_right
+        last_rect = group[-1]
+        hp_right = last_rect.pos[0], last_rect.pos[1]
+        x, y = self.to_local(*hp_right, relative=True)
+        handle_right.x = x + last_rect.size[0]
+        handle_right.y = y - handle_right.height
+
+    def _hide_handles(self, win=None):
+        win = win or EventLoop.window
+        if win is None:
+            return
+        win.remove_widget(self._handle_right)
+        win.remove_widget(self._handle_left)
+        win.remove_widget(self._handle_middle)
+
+    def _show_handles(self, dt):
+        if not self.use_handles or not self.text:
+            return
+
+        win = EventLoop.window
+
+        handle_right = self._handle_right
+        handle_left = self._handle_left
+        if self._handle_left is None:
+            self._handle_left = handle_left = Selector(
+                source=self.handle_image_left,
+                target=self,
+                window=win,
+                size_hint=(None, None),
+                size=('45dp', '45dp'))
+            handle_left.bind(on_press=self._handle_pressed,
+                             on_touch_move=self._handle_move,
+                             on_release=self._handle_released)
+            self._handle_right = handle_right = Selector(
+                source=self.handle_image_right,
+                target=self,
+                window=win,
+                size_hint=(None, None),
+                size=('45dp', '45dp'))
+            handle_right.bind(on_press=self._handle_pressed,
+                              on_touch_move=self._handle_move,
+                              on_release=self._handle_released)
+        else:
+            if self._handle_left.parent:
+                self._position_handles()
+                return
+            if not self.parent:
+                return
+
+        self._trigger_position_handles()
+        if self.selection_from != self.selection_to:
+            self._handle_left.opacity = self._handle_right.opacity = 0
+            win.add_widget(self._handle_left, canvas='after')
+            win.add_widget(self._handle_right, canvas='after')
+            anim = Animation(opacity=1, d=.4)
+            anim.start(self._handle_right)
+            anim.start(self._handle_left)
+
+    def _show_cut_copy_paste(
+        self, pos, win, parent_changed=False, mode='', pos_in_window=False, *l
+    ):
+        """Show a bubble with cut copy and paste buttons"""
+        if not self.use_bubble:
+            return
+
+        bubble = self._bubble
+        if bubble is None:
+            self._bubble = bubble = TextInputCutCopyPaste(textinput=self)
+            self.fbind('parent', self._show_cut_copy_paste, pos, win, True)
+
+            def hide_(*args):
+                return self._hide_cut_copy_paste(win)
+
+            self.bind(
+                focus=hide_,
+                cursor_pos=hide_,
+            )
+        else:
+            win.remove_widget(bubble)
+            if not self.parent:
+                return
+        if parent_changed:
+            return
+
+        # Search the position from the touch to the window
+        lh, ls = self.line_height, self.line_spacing
+
+        x, y = pos
+        t_pos = (x, y) if pos_in_window else self.to_window(x, y)
+        bubble_size = bubble.size
+        bubble_hw = bubble_size[0] / 2.
+        win_size = win.size
+        bubble_pos = (t_pos[0], t_pos[1] + inch(.25))
+
+        if (bubble_pos[0] - bubble_hw) < 0:
+            # bubble beyond left of window
+            if bubble_pos[1] > (win_size[1] - bubble_size[1]):
+                # bubble above window height
+                bubble_pos = (bubble_hw, (t_pos[1]) - (lh + ls + inch(.25)))
+                bubble.arrow_pos = 'top_left'
+            else:
+                bubble_pos = (bubble_hw, bubble_pos[1])
+                bubble.arrow_pos = 'bottom_left'
+        elif (bubble_pos[0] + bubble_hw) > win_size[0]:
+            # bubble beyond right of window
+            if bubble_pos[1] > (win_size[1] - bubble_size[1]):
+                # bubble above window height
+                bubble_pos = (
+                    win_size[0] - bubble_hw,
+                    (t_pos[1]) - (lh + ls + inch(.25))
+                )
+                bubble.arrow_pos = 'top_right'
+            else:
+                bubble_pos = (win_size[0] - bubble_hw, bubble_pos[1])
+                bubble.arrow_pos = 'bottom_right'
+        else:
+            if bubble_pos[1] > (win_size[1] - bubble_size[1]):
+                # bubble above window height
+                bubble_pos = (
+                    bubble_pos[0],
+                    (t_pos[1]) - (lh + ls + inch(.25))
+                )
+                bubble.arrow_pos = 'top_mid'
+            else:
+                bubble.arrow_pos = 'bottom_mid'
+
+        bubble_pos = self.to_widget(*bubble_pos, relative=True)
+        bubble.center_x = bubble_pos[0]
+        if bubble.arrow_pos[0] == 't':
+            bubble.top = bubble_pos[1]
+        else:
+            bubble.y = bubble_pos[1]
+        bubble.mode = mode
+        Animation.cancel_all(bubble)
+        bubble.opacity = 0
+        win.add_widget(bubble, canvas='after')
+        Animation(opacity=1, d=.225).start(bubble)
+
+    def _hide_cut_copy_paste(self, win=None):
+        bubble = self._bubble
+        if not bubble:
+            return
+
+        bubble.hide()
+
+    #
+    # Private
+    #
+
+    @staticmethod
+    def _reload_remove_observer(wr):
+        """called when the textinput is deleted"""
+        if wr in _textinput_list:
+            _textinput_list.remove(wr)
+
+    def _on_textinput_focused(self, instance, value, *largs):
+        win = EventLoop.window
+        self.cancel_selection()
+        self._hide_cut_copy_paste(win)
+
+        if value:
+            if (
+                not (self.readonly or self.disabled)
+                or _is_desktop
+                and self._keyboard_mode == 'system'
+            ):
+                self._trigger_cursor_reset()
+                self._editable = True
+            else:
+                self._editable = False
+        else:
+            self._do_blink_cursor_ev.cancel()
+            self._hide_handles(win)
+
+    def _ensure_clipboard(self):
+        global Clipboard, CutBuffer
+        if not Clipboard:
+            from kivy.core.clipboard import Clipboard, CutBuffer
+
+    def cut(self):
+        ''' Copy current selection to clipboard then delete it from TextInput.
+
+        .. versionadded:: 1.8.0
+
+        '''
+        self._cut(self.selection_text)
+
+    def _cut(self, data):
+        self._ensure_clipboard()
+        Clipboard.copy(data)
+        self.delete_selection()
+
+    def copy(self, data=''):
+        ''' Copy the value provided in argument `data` into current clipboard.
+        If data is not of type string it will be converted to string.
+        If no data is provided then current selection if present is copied.
+
+        .. versionadded:: 1.8.0
+
+        '''
+        self._ensure_clipboard()
+        if data:
+            return Clipboard.copy(data)
+        if self.selection_text:
+            return Clipboard.copy(self.selection_text)
+
+    def paste(self):
+        ''' Insert text from system :class:`~kivy.core.clipboard.Clipboard`
+        into the :class:`~kivy.uix.textinput.TextInput` at current cursor
+        position.
+
+        .. versionadded:: 1.8.0
+
+        '''
+        self._ensure_clipboard()
+        data = Clipboard.paste()
+        self.delete_selection()
+        self.insert_text(data)
+
+    def _update_cutbuffer(self, *args):
+        CutBuffer.set_cutbuffer(self.selection_text)
+
+    def _get_text_width(self, text, tab_width, _label_cached):
+        """Return the width of a text, according to the current line options"""
+        kw = self._get_line_options()
+
+        try:
+            cid = u'{}\0{}\0{}'.format(text, self.password, kw)
+        except UnicodeDecodeError:
+            cid = '{}\0{}\0{}'.format(text, self.password, kw)
+
+        width = Cache_get('textinput.width', cid)
+        if width:
+            return width
+        if not _label_cached:
+            _label_cached = self._label_cached
+        text = text.replace('\t', ' ' * tab_width)
+        if not self.password:
+            width = _label_cached.get_extents(text)[0]
+        else:
+            width = _label_cached.get_extents(
+                self.password_mask * len(text))[0]
+        Cache_append('textinput.width', cid, width)
+        return width
+
+    def on_cursor_blink(self, instance, value):
+        """trigger blink event reset to switch blinking while focused"""
+        self._reset_cursor_blink()
+
+    def _do_blink_cursor(self, dt):
+        if not self.cursor_blink:
+            # ignore event if not triggered,
+            # stop if cursor_blink value changed right now
+            if self._do_blink_cursor_ev.is_triggered:
+                self._do_blink_cursor_ev.cancel()
+            # don't blink, make cursor visible
+            self._cursor_blink = False
+            return
+
+        # Callback for blinking the cursor.
+        self._cursor_blink = not self._cursor_blink
+
+    def _reset_cursor_blink(self, *args):
+        self._do_blink_cursor_ev.cancel()
+        self._cursor_blink = False
+        self._do_blink_cursor_ev()
+
+    def on_cursor(self, instance, value):
+        """
+        When the cursor is moved, reset cursor blinking to keep it showing,
+        and update all the graphics.
+        """
+        if self.focus:
+            self._trigger_cursor_reset()
+        self._trigger_update_graphics()
+
+    def _delete_line(self, idx):
+        """Delete current line, and fix cursor position"""
+        assert(idx < len(self._lines))
+        self._lines_flags.pop(idx)
+        self._lines_labels.pop(idx)
+        self._lines.pop(idx)
+        self.cursor = self.cursor
+
+    def _set_line_text(self, line_num, text):
+        """Set current line with other text than the default one."""
+        self._lines_labels[line_num] = self._create_line_label(text)
+        self._lines[line_num] = text
+
+    def _trigger_refresh_line_options(self, *largs):
+        if self._refresh_line_options_ev is not None:
+            self._refresh_line_options_ev.cancel()
+        else:
+            self._refresh_line_options_ev = Clock.create_trigger(
+                self._refresh_line_options, 0)
+        self._refresh_line_options_ev()
+
+    def _refresh_line_options(self, *largs):
+        self._line_options = None
+        self._get_line_options()
+        self._refresh_text_from_property()
+        self._refresh_hint_text()
+        self.cursor = self.get_cursor_from_index(len(self.text))
+
+    def _trigger_refresh_text(self, *largs):
+        if len(largs) and largs[0] == self:
+            largs = ()
+        if self._refresh_text_from_property_ev is not None:
+            self._refresh_text_from_property_ev.cancel()
+        self._refresh_text_from_property_ev = Clock.schedule_once(
+            lambda dt: self._refresh_text_from_property(*largs))
+
+    def _update_text_options(self, *largs):
+        Cache_remove('textinput.width')
+        self._trigger_refresh_text()
+
+    def _refresh_text_from_trigger(self, dt, *largs):
+        self._refresh_text_from_property(*largs)
+
+    def _refresh_text_from_property(self, *largs):
+        self._refresh_text(self.text, *largs)
+
+    def _refresh_text(self, text, *largs):
+        """
+        Refresh all the lines from a new text.
+        By using cache in internal functions, this method should be fast.
+        """
+        mode = 'all'
+        if len(largs) > 1:
+            mode, start, finish, _lines, _lines_flags, len_lines = largs
+            # start = max(0, start)
+            cursor = None
+        else:
+            cursor = self.cursor_index()
+            _lines, self._lines_flags = self._split_smart(text)
+        _lines_labels = []
+        _line_rects = []
+        _create_label = self._create_line_label
+
+        for x in _lines:
+            lbl = _create_label(x)
+            _lines_labels.append(lbl)
+            _line_rects.append(Rectangle(size=lbl.size))
+
+        if mode == 'all':
+            self._lines_labels = _lines_labels
+            self._lines_rects = _line_rects
+            self._lines[:] = _lines
+        elif mode == 'del':
+            if finish > start:
+                self._insert_lines(start, finish + 1, len_lines,
+                                   _lines_flags, _lines, _lines_labels,
+                                   _line_rects)
+        elif mode == 'insert':
+            self._insert_lines(start, finish + 1, len_lines, _lines_flags,
+                               _lines, _lines_labels, _line_rects)
+
+        min_line_ht = self._label_cached.get_extents('_')[1]
+        # with markup texture can be of height `1`
+        self.line_height = max(_lines_labels[0].height, min_line_ht)
+        # self.line_spacing = 2
+        # now, if the text change, maybe the cursor is not at the same place as
+        # before. so, try to set the cursor on the good place
+        row = self.cursor_row
+        self.cursor = self.get_cursor_from_index(
+            self.cursor_index() if cursor is None else cursor
+        )
+
+        # if we back to a new line, reset the scroll, otherwise, the effect is
+        # ugly
+        if self.cursor_row != row:
+            self.scroll_x = 0
+        # with the new text don't forget to update graphics again
+        self._trigger_update_graphics()
+
+    def _insert_lines(self, start, finish, len_lines, _lines_flags,
+                      _lines, _lines_labels, _line_rects):
+        self_lines_flags = self._lines_flags
+        _lins_flags = []
+        _lins_flags.extend(self_lines_flags[:start])
+        if len_lines:
+            # if not inserting at first line then
+            if start:
+                # make sure line flags restored for first line
+                # _split_smart assumes first line to be not a new line
+                _lines_flags[0] = self_lines_flags[start]
+            _lins_flags.extend(_lines_flags)
+        _lins_flags.extend(self_lines_flags[finish:])
+        self._lines_flags = _lins_flags
+
+        _lins_lbls = []
+        _lins_lbls.extend(self._lines_labels[:start])
+        if len_lines:
+            _lins_lbls.extend(_lines_labels)
+        _lins_lbls.extend(self._lines_labels[finish:])
+        self._lines_labels = _lins_lbls
+
+        _lins_rcts = []
+        _lins_rcts.extend(self._lines_rects[:start])
+        if len_lines:
+            _lins_rcts.extend(_line_rects)
+        _lins_rcts.extend(self._lines_rects[finish:])
+        self._lines_rects = _lins_rcts
+
+        _lins = []
+        _lins.extend(self._lines[:start])
+        if len_lines:
+            _lins.extend(_lines)
+        _lins.extend(self._lines[finish:])
+        self._lines[:] = _lins
+
+    def _trigger_update_graphics(self, *largs):
+        self._update_graphics_ev.cancel()
+        self._update_graphics_ev()
+
+    def _update_graphics(self, *largs):
+        """
+        Update all the graphics according to the current internal values.
+        """
+
+        # This is a little bit complex, because we have to :
+        #     - handle scroll_x
+        #     - handle padding
+        #     - create rectangle for the lines matching the viewport
+        #     - crop the texture coordinates to match the viewport
+
+        # This is the first step of graphics, the second is the selection.
+
+        self.canvas.clear()
+
+        line_height = self.line_height
+        dy = line_height + self.line_spacing
+
+        # adjust view if the cursor is going outside the bounds
+        scroll_x = self.scroll_x
+        scroll_y = self.scroll_y
+
+        # draw labels
+        if (
+            not self._lines
+            or (not self._lines[0] and len(self._lines) == 1)
+        ):
+            rects = self._hint_text_rects
+            labels = self._hint_text_labels
+            lines = self._hint_text_lines
+        else:
+            rects = self._lines_rects
+            labels = self._lines_labels
+            lines = self._lines
+
+        padding_left, padding_top, padding_right, padding_bottom = self.padding
+        x = self.x + padding_left
+        y = self.top - padding_top + scroll_y
+        miny = self.y + padding_bottom
+        maxy = self.top - padding_top
+        halign = self.halign
+        base_dir = self.base_direction
+
+        auto_halign_r = halign == 'auto' and base_dir and 'rtl' in base_dir
+
+        fst_visible_ln = None
+        viewport_pos = scroll_x, 0
+        for line_num, value in enumerate(lines):
+            if miny < y < maxy + dy:
+                if fst_visible_ln is None:
+                    fst_visible_ln = line_num
+
+                y = self._draw_line(
+                    value,
+                    line_num,
+                    labels[line_num],
+                    viewport_pos,
+                    line_height,
+                    miny,
+                    maxy,
+                    x,
+                    y,
+                    base_dir,
+                    halign,
+                    rects,
+                    auto_halign_r,
+                )
+            elif y <= miny:
+                line_num -= 1
+                break
+
+            y -= dy
+
+        if fst_visible_ln is not None:
+            self._visible_lines_range = (fst_visible_ln, line_num + 1)
+        else:
+            self._visible_lines_range = 0, 0
+
+        self._update_graphics_selection()
+
+    def _draw_line(
+        self,
+        value,
+        line_num,
+        texture,
+        viewport_pos,
+        line_height,
+        miny,
+        maxy,
+        x,
+        y,
+        base_dir,
+        halign,
+        rects,
+        auto_halign_r,
+    ):
+        size = list(texture.size)
+        texcoords = texture.tex_coords[:]
+
+        # compute coordinate
+        padding_left, padding_top, padding_right, padding_bottom = self.padding
+        viewport_width = self.width - padding_left - padding_right
+        viewport_height = self.height - padding_top - padding_bottom
+        texture_width, texture_height = size
+        original_height, original_width = tch, tcw = texcoords[1:3]
+
+        # adjust size/texcoord according to viewport
+        if viewport_pos:
+            tcx, tcy = viewport_pos
+            tcx = tcx / texture_width * original_width
+            tcy = tcy / texture_height * original_height
+
+        else:
+            tcx, tcy = 0, 0
+
+        if texture_width * (1 - tcx) < viewport_width:
+            tcw = tcw - tcx
+            texture_width = tcw * texture_width
+        elif viewport_width < texture_width:
+            tcw = (viewport_width / texture_width) * tcw
+            texture_width = viewport_width
+
+        if viewport_height < texture_height:
+            tch = (viewport_height / texture_height) * tch
+            texture_height = viewport_height
+
+        # cropping
+        if y > maxy:
+            viewport_height = (maxy - y + line_height)
+            tch = (viewport_height / line_height) * original_height
+            tcy = original_height - tch
+            texture_height = viewport_height
+        if y - line_height < miny:
+            diff = miny - (y - line_height)
+            y += diff
+            viewport_height = line_height - diff
+            tch = (viewport_height / line_height) * original_height
+            texture_height = viewport_height
+
+        if tcw < 0:
+            # nothing to show
+            return y
+
+        top_left_corner = tcx, tcy + tch
+        top_right_corner = tcx + tcw, tcy + tch
+        bottom_right_corner = tcx + tcw, tcy
+        bottom_left_corner = tcx, tcy
+
+        texcoords = (
+            top_left_corner
+            + top_right_corner
+            + bottom_right_corner
+            + bottom_left_corner
+        )
+
+        # Horizontal alignment
+        xoffset = 0
+        if not base_dir:
+            base_dir = self._resolved_base_dir = Label.find_base_direction(value)  # noqa
+            if base_dir and halign == 'auto':
+                auto_halign_r = 'rtl' in base_dir
+        if halign == 'center':
+            xoffset = int((viewport_width - texture_width) / 2.)
+        elif halign == 'right' or auto_halign_r:
+            xoffset = max(0, int(viewport_width - texture_width))
+
+        # add rectangle
+        rect = rects[line_num]
+        rect.pos = int(xoffset + x), int(y - line_height)
+        rect.size = texture_width, texture_height
+        rect.texture = texture
+        rect.tex_coords = texcoords
+        # useful to debug rectangle sizes
+        # self.canvas.add(Color(0, .5, 0, .5, mode='rgba'))
+        # self.canvas.add(Rectangle(pos=rect.pos, size=rect.size))
+        # self.canvas.add(Color())
+        self.canvas.add(rect)
+
+        return y
+
+    def _update_graphics_selection(self):
+        if not self._selection:
+            return
+
+        # local references to avoid dot lookups later
+        padding_left, padding_top, padding_right, padding_bottom = self.padding
+        rects = self._lines_rects
+        label_cached = self._label_cached
+        lines = self._lines
+        tab_width = self.tab_width
+        top = self.top
+        get_text_width = self._get_text_width
+        get_cursor_from_index = self.get_cursor_from_index
+        draw_selection = self._draw_selection
+        canvas_add = self.canvas.add
+        selection_color = self.selection_color
+
+        # selection borders
+        a, b = sorted((self._selection_from, self._selection_to))
+        selection_start_col, selection_start_row = get_cursor_from_index(a)
+        selection_end_col, selection_end_row = get_cursor_from_index(b)
+
+        dy = self.line_height + self.line_spacing
+        x = self.x
+        y = top - padding_top + self.scroll_y - selection_start_row * dy
+        width = self.width
+
+        miny = self.y + padding_bottom
+        maxy = top - padding_top + dy
+
+        self.canvas.remove_group('selection')
+        first_visible_line = math.floor(self.scroll_y / dy)
+        last_visible_line = math.ceil((self.scroll_y + maxy - miny) / dy)
+        width_minus_padding = width - (padding_right + padding_left)
+
+        for line_num, rect in enumerate(
+            islice(
+                rects,
+                max(selection_start_row, first_visible_line),
+                min(selection_end_row + 1, last_visible_line - 1),
+            ),
+            start=max(selection_start_row, first_visible_line)
+        ):
+            draw_selection(
+                rect.pos,
+                rect.size,
+                line_num,
+                (selection_start_col, selection_start_row),
+                (selection_end_col, selection_end_row),
+                lines,
+                get_text_width,
+                tab_width,
+                label_cached,
+                width_minus_padding,
+                padding_left,
+                padding_right,
+                x,
+                canvas_add,
+                selection_color
+            )
+        self._position_handles('both')
+
+    def _draw_selection(
+        self,
+        pos,
+        size,
+        line_num,
+        selection_start,
+        selection_end,
+        lines,
+        get_text_width,
+        tab_width,
+        label_cached,
+        width_minus_padding,
+        padding_left,
+        padding_right,
+        x,
+        canvas_add,
+        selection_color
+    ):
+        selection_start_col, selection_start_row = selection_start
+        selection_end_col, selection_end_row = selection_end
+
+        # Draw the current selection on the widget.
+        if not selection_start_row <= line_num <= selection_end_row:
+            return
+        x, y = pos
+        w, h = size
+        beg = x
+        end = x + w
+
+        if line_num == selection_start_row:
+            line = lines[line_num]
+            beg -= self.scroll_x
+            beg += get_text_width(
+                line[:selection_start_col],
+                tab_width,
+                label_cached
+            )
+
+        if line_num == selection_end_row:
+            line = lines[line_num]
+            end = (x - self.scroll_x) + get_text_width(
+                line[:selection_end_col],
+                tab_width,
+                label_cached
+            )
+
+        beg = boundary(beg, x, x + width_minus_padding)
+        end = boundary(end, x, x + width_minus_padding)
+        if beg == end:
+            return
+
+        canvas_add(Color(*selection_color, group='selection'))
+        canvas_add(
+            Rectangle(
+                pos=(beg, y),
+                size=(end - beg, h),
+                group='selection'
+            )
+        )
+
+    def on_size(self, instance, value):
+        # if the size change, we might do invalid scrolling / text split
+        # size the text maybe be put after size_hint have been resolved.
+        self._trigger_refresh_text()
+        self._refresh_hint_text()
+        self.scroll_x = self.scroll_y = 0
+
+    def _get_row_width(self, row):
+        # Get the pixel width of the given row.
+        _labels = self._lines_labels
+        if row < len(_labels):
+            return _labels[row].width
+        return 0
+
+    def _get_cursor_pos(self):
+        # return the current cursor x/y from the row/col
+        dy = self.line_height + self.line_spacing
+        padding_left = self.padding[0]
+        padding_top = self.padding[1]
+        padding_right = self.padding[2]
+        left = self.x + padding_left
+        top = self.top - padding_top
+        y = top + self.scroll_y
+        y -= self.cursor_row * dy
+
+        # Horizontal alignment
+        halign = self.halign
+        viewport_width = self.width - padding_left - padding_right
+        cursor_offset = self.cursor_offset()
+        base_dir = self.base_direction or self._resolved_base_dir
+        auto_halign_r = halign == 'auto' and base_dir and 'rtl' in base_dir
+        if halign == 'center':
+            row_width = self._get_row_width(self.cursor_row)
+            x = (
+                left
+                + max(0, (viewport_width - row_width) // 2)
+                + cursor_offset
+                - self.scroll_x
+            )
+        elif halign == 'right' or auto_halign_r:
+            row_width = self._get_row_width(self.cursor_row)
+            x = (
+                left
+                + max(0, viewport_width - row_width)
+                + cursor_offset
+                - self.scroll_x
+            )
+        else:
+            x = left + cursor_offset - self.scroll_x
+
+        return x, y
+
+    def _get_cursor_visual_height(self):
+        # Return the height of the cursor's visible part
+        _, cy = map(int, self.cursor_pos)
+        max_y = self.top - self.padding[1]
+        min_y = self.y + self.padding[3]
+
+        lh = self.line_height
+        if cy > max_y:
+            return lh - min(lh, cy - max_y)
+        else:
+            return min(lh, max(0, cy - min_y))
+
+    def _get_cursor_visual_pos(self):
+        # Return the position of the cursor's top visible point
+        cx, cy = map(int, self.cursor_pos)
+        max_y = self.top - self.padding[3]
+        return [cx, min(max_y, cy)]
+
+    def _get_line_options(self):
+        # Get or create line options, to be used for Label creation
+        if self._line_options is None:
+            self._line_options = kw = {
+                'font_size': self.font_size,
+                'font_name': self.font_name,
+                'font_context': self.font_context,
+                'font_family': self.font_family,
+                'text_language': self.text_language,
+                'base_direction': self.base_direction,
+                'anchor_x': 'left',
+                'anchor_y': 'top',
+                'padding_x': 0,
+                'padding_y': 0,
+                'padding': (0, 0)
+            }
+            self._label_cached = Label(**kw)
+        return self._line_options
+
+    def _create_line_label(self, text, hint=False):
+        # Create a label from a text, using line options
+        ntext = text.replace(u'\n', u'').replace(u'\t', u' ' * self.tab_width)
+
+        if self.password and not hint:  # Don't replace hint_text with *
+            ntext = self.password_mask * len(ntext)
+
+        kw = self._get_line_options()
+        cid = '%s\0%s' % (ntext, str(kw))
+        texture = Cache_get('textinput.label', cid)
+
+        if texture is None:
+            # FIXME right now, we can't render very long line...
+            # if we move on "VBO" version as fallback, we won't need to
+            # do this. try to find the maximum text we can handle
+            label = None
+            label_len = len(ntext)
+            ld = None
+
+            # check for blank line
+            if not ntext:
+                texture = Texture.create(size=(1, 1))
+                Cache_append('textinput.label', cid, texture)
+                return texture
+
+            while True:
+                try:
+                    label = Label(text=ntext[:label_len], **kw)
+                    label.refresh()
+                    if ld is not None and ld > 2:
+                        ld //= 2
+                        label_len += ld
+                    else:
+                        break
+
+                except:
+                    # exception happen when we tried to render the text
+                    # reduce it...
+                    if ld is None:
+                        ld = len(ntext)
+                    ld //= 2
+                    if ld < 2 and label_len:
+                        label_len -= 1
+                    label_len -= ld
+                    continue
+
+            # ok, we found it.
+            texture = label.texture
+            Cache_append('textinput.label', cid, texture)
+        return texture
+
+    _tokenize_delimiters = u' .,:;!?\r\t'
+
+    def _tokenize(self, text):
+        # Tokenize a text string from some delimiters
+        if text is None:
+            return
+        delimiters = self._tokenize_delimiters
+        old_index = 0
+        prev_char = ''
+        for index, char in enumerate(text):
+            if char not in delimiters:
+                if char != u'\n':
+                    if index > 0 and (prev_char in delimiters):
+                        if old_index < index:
+                            yield text[old_index:index]
+                        old_index = index
+                else:
+                    if old_index < index:
+                        yield text[old_index:index]
+                    yield text[index:index + 1]
+                    old_index = index + 1
+            prev_char = char
+        yield text[old_index:]
+
+    def _split_smart(self, text):
+        """
+        Do a "smart" split. If not multiline, or if wrap is set,
+        we are not doing smart split, just a split on line break.
+        Otherwise, we are trying to split as soon as possible, to prevent
+        overflow on the widget.
+        """
+
+        # depend of the options, split the text on line, or word
+        if not self.multiline or not self.do_wrap:
+            lines = text.split(u'\n')
+            lines_flags = [0] + [FL_IS_LINEBREAK] * (len(lines) - 1)
+            return lines, lines_flags
+
+        # no autosize, do wordwrap.
+        x = flags = 0
+        line = []
+        lines = []
+        lines_flags = []
+        _join = u''.join
+        lines_append, lines_flags_append = lines.append, lines_flags.append
+        padding_left = self.padding[0]
+        padding_right = self.padding[2]
+        width = self.width - padding_left - padding_right
+        text_width = self._get_text_width
+        _tab_width, _label_cached = self.tab_width, self._label_cached
+
+        # try to add each word on current line.
+        words_widths = {}
+        for word in self._tokenize(text):
+            is_newline = (word == u'\n')
+            try:
+                w = words_widths[word]
+            except KeyError:
+                w = text_width(word, _tab_width, _label_cached)
+                words_widths[word] = w
+            # if we have more than the width, or if it's a newline,
+            # push the current line, and create a new one
+            if (x + w > width and line) or is_newline:
+                lines_append(_join(line))
+                lines_flags_append(flags)
+                flags = 0
+                line = []
+                x = 0
+            if is_newline:
+                flags |= FL_IS_LINEBREAK
+            elif width >= 1 and w > width:
+                while w > width:
+                    split_width = split_pos = 0
+                    # split the word
+                    for c in word:
+                        try:
+                            cw = words_widths[c]
+                        except KeyError:
+                            cw = text_width(c, _tab_width, _label_cached)
+                            words_widths[c] = cw
+                        if split_width + cw > width:
+                            break
+                        split_width += cw
+                        split_pos += 1
+                    if split_width == split_pos == 0:
+                        # can't fit the word in, give up
+                        break
+                    lines_append(word[:split_pos])
+                    lines_flags_append(flags)
+                    flags = FL_IS_WORDBREAK
+                    word = word[split_pos:]
+                    w -= split_width
+                x = w
+                line.append(word)
+            else:
+                x += w
+                line.append(word)
+        if line or flags & FL_IS_LINEBREAK:
+            lines_append(_join(line))
+            lines_flags_append(flags)
+
+        return lines, lines_flags
+
+    def _key_down(self, key, repeat=False):
+        displayed_str, internal_str, internal_action, scale = key
+
+        # handle deletion
+        if (
+            self._selection
+            and internal_action in (None, 'del', 'backspace', 'enter')
+            and (internal_action != 'enter' or self.multiline)
+        ):
+            self.delete_selection()
+
+        elif internal_action == 'del':
+            # Move cursor one char to the right. If that was successful,
+            # do a backspace (effectively deleting char right of cursor)
+            cursor = self.cursor
+            self.do_cursor_movement('cursor_right')
+            if cursor != self.cursor:
+                self.do_backspace(mode='del')
+
+        elif internal_action == 'backspace':
+            self.do_backspace()
+
+        # handle action keys and text insertion
+        if internal_action is None:
+            self.insert_text(displayed_str)
+
+        elif internal_action in ('shift', 'shift_L', 'shift_R'):
+            if not self._selection:
+                self._selection_from = self._selection_to = self.cursor_index()
+                self._selection = True
+            self._selection_finished = False
+
+        elif internal_action == 'ctrl_L':
+            self._ctrl_l = True
+
+        elif internal_action == 'ctrl_R':
+            self._ctrl_r = True
+
+        elif internal_action == 'alt_L':
+            self._alt_l = True
+
+        elif internal_action == 'alt_R':
+            self._alt_r = True
+
+        elif internal_action.startswith('cursor_'):
+            cc, cr = self.cursor
+            self.do_cursor_movement(
+                internal_action,
+                self._ctrl_l or self._ctrl_r,
+                self._alt_l or self._alt_r
+            )
+            if self._selection and not self._selection_finished:
+                self._selection_to = self.cursor_index()
+                self._update_selection()
+            else:
+                self.cancel_selection()
+
+        elif internal_action == 'enter':
+            if self.multiline:
+                self.insert_text(u'\n')
+            else:
+                self.dispatch('on_text_validate')
+                if self.text_validate_unfocus:
+                    self.focus = False
+
+        elif internal_action == 'escape':
+            self.focus = False
+
+    def _key_up(self, key, repeat=False):
+        displayed_str, internal_str, internal_action, scale = key
+        if internal_action in ('shift', 'shift_L', 'shift_R'):
+            if self._selection:
+                self._update_selection(True)
+        elif internal_action == 'ctrl_L':
+            self._ctrl_l = False
+        elif internal_action == 'ctrl_R':
+            self._ctrl_r = False
+        elif internal_action == 'alt_L':
+            self._alt_l = False
+        elif internal_action == 'alt_R':
+            self._alt_r = False
+
+    def keyboard_on_key_down(self, window, keycode, text, modifiers):
+        key, _ = keycode
+        win = EventLoop.window
+
+        # This allows *either* ctrl *or* cmd, but not both.
+        modifiers = set(modifiers) - {'capslock', 'numlock'}
+        is_shortcut = (
+            modifiers == {'ctrl'}
+            or _is_osx and modifiers == {'meta'}
+        )
+        is_interesting_key = key in self.interesting_keys.keys()
+
+        if (
+            not self.write_tab
+            and super().keyboard_on_key_down(window, keycode, text, modifiers)
+        ):
+            return True
+
+        if text and is_shortcut and not is_interesting_key:
+            self._handle_shortcut(key)
+
+        elif self._editable and text and not is_interesting_key:
+            self._hide_handles(win)
+            self._hide_cut_copy_paste(win)
+            win.remove_widget(self._handle_middle)
+
+            # check for command modes
+            # we use \x01INFO\x02 to get info from IME on mobiles
+            # pygame seems to pass \x01 as the unicode for ctrl+a
+            # checking for modifiers ensures conflict resolution.
+
+            first_char = ord(text[0])
+            if not modifiers and first_char == 1:
+                self._command_mode = True
+                self._command = ''
+            if not modifiers and first_char == 2:
+                self._command_mode = False
+                self._command = self._command[1:]
+
+            if self._command_mode:
+                self._command += text
+                return
+
+            _command = self._command
+            if _command and first_char == 2:
+                self._handle_command(_command)
+                return
+
+            else:
+                if EventLoop.window.managed_textinput:
+                    # we expect to get managed key input via on_textinput
+                    return
+                if self._selection:
+                    self.delete_selection()
+                self.insert_text(text)
+            # self._recalc_size()
+            return
+
+        if is_interesting_key:
+            self._hide_cut_copy_paste(win)
+            self._hide_handles(win)
+
+        if key == 27:  # escape
+            self.focus = False
+            return True
+        elif key == 9:  # tab
+            self.delete_selection()
+            self.insert_text(u'\t')
+            return True
+
+        k = self.interesting_keys.get(key)
+        if k:
+            key = (None, None, k, 1)
+            self._key_down(key)
+
+    def _handle_command(self, command):
+        from_undo = True
+        command, data = command.split(':')
+        self._command = ''
+        if self._selection:
+            self.delete_selection()
+        if command == 'DEL':
+            count = int(data)
+            if not count:
+                self.delete_selection(from_undo=True)
+            end = self.cursor_index()
+            self._selection_from = max(end - count, 0)
+            self._selection_to = end
+            self._selection = True
+            self.delete_selection(from_undo=True)
+            return
+        elif command == 'INSERT':
+            self.insert_text(data, from_undo)
+        elif command == 'INSERTN':
+            from_undo = False
+            self.insert_text(data, from_undo)
+        elif command == 'SELWORD':
+            self.dispatch('on_double_tap')
+        elif command == 'SEL':
+            if data == '0':
+                Clock.schedule_once(lambda dt: self.cancel_selection())
+        elif command == 'CURCOL':
+            self.cursor = int(data), self.cursor_row
+
+    def _handle_shortcut(self, key):
+        # actions that can be done in readonly
+        if key == ord('a'):  # select all
+            self.select_all()
+        elif key == ord('c'):  # copy selection
+            self.copy()
+
+        if not self._editable:
+            return
+
+        # actions that can be done only if editable
+        if key == ord('x'):  # cut selection
+            self._cut(self.selection_text)
+        elif key == ord('v'):  # paste clipboard content
+            self.paste()
+        elif key == ord('z'):  # undo
+            self.do_undo()
+        elif key == ord('r'):  # redo
+            self.do_redo()
+
+    def keyboard_on_key_up(self, window, keycode):
+        key = keycode[0]
+        k = self.interesting_keys.get(key)
+        if k:
+            key = (None, None, k, 1)
+            self._key_up(key)
+
+    def keyboard_on_textinput(self, window, text):
+        if self._selection:
+            self.delete_selection()
+        self.insert_text(text, False)
+
+    # current IME composition in progress by the IME system, or '' if nothing
+    _ime_composition = StringProperty('')
+    # cursor position of last IME event
+    _ime_cursor = ListProperty(None, allownone=True)
+
+    def _bind_keyboard(self):
+        super()._bind_keyboard()
+        Window.bind(on_textedit=self.window_on_textedit)
+
+    def _unbind_keyboard(self):
+        super()._unbind_keyboard()
+        Window.unbind(on_textedit=self.window_on_textedit)
+
+    def window_on_textedit(self, window, ime_input):
+        text_lines = self._lines or ['']
+        if self._ime_composition:
+            pcc, pcr = self._ime_cursor
+            text = text_lines[pcr]
+            len_ime = len(self._ime_composition)
+            if text[pcc - len_ime:pcc] == self._ime_composition:  # always?
+                remove_old_ime_text = text[:pcc - len_ime] + text[pcc:]
+                ci = self.cursor_index()
+                self._refresh_text_from_property(
+                    "insert",
+                    *self._get_line_from_cursor(pcr, remove_old_ime_text)
+                )
+                self.cursor = self.get_cursor_from_index(ci - len_ime)
+
+        if ime_input:
+            if self._selection:
+                self.delete_selection()
+            cc, cr = self.cursor
+            text = text_lines[cr]
+            new_text = text[:cc] + ime_input + text[cc:]
+            self._refresh_text_from_property(
+                "insert", *self._get_line_from_cursor(cr, new_text)
+            )
+            self.cursor = self.get_cursor_from_index(
+                self.cursor_index() + len(ime_input)
+            )
+        self._ime_composition = ime_input
+        self._ime_cursor = self.cursor
+
+    def on__hint_text(self, instance, value):
+        self._refresh_hint_text()
+
+    def _refresh_hint_text(self):
+        _lines, self._hint_text_flags = self._split_smart(self.hint_text)
+        _hint_text_labels = []
+        _hint_text_rects = []
+        _create_label = self._create_line_label
+
+        for x in _lines:
+            lbl = _create_label(x, hint=True)
+            _hint_text_labels.append(lbl)
+            _hint_text_rects.append(Rectangle(size=lbl.size))
+
+        self._hint_text_lines[:] = _lines
+        self._hint_text_labels = _hint_text_labels
+        self._hint_text_rects = _hint_text_rects
+
+        # Remember to update graphics
+        self._trigger_update_graphics()
+
+    #
+    # Properties
+    #
+
+    _lines = ListProperty([])
+    _hint_text_lines = ListProperty([])
+    _editable = BooleanProperty(True)
+    _insert_int_pat = re.compile(u'^-?[0-9]*$')
+    _insert_float_pat = re.compile(u'^-?[0-9]*\\.?[0-9]*$')
+    _cursor_blink = BooleanProperty(False)
+    _cursor_visual_pos = AliasProperty(
+        _get_cursor_visual_pos, None, bind=['cursor_pos']
+    )
+    _cursor_visual_height = AliasProperty(
+        _get_cursor_visual_height, None, bind=['cursor_pos']
+    )
+
+    readonly = BooleanProperty(False)
+    '''If True, the user will not be able to change the content of a textinput.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`readonly` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    text_validate_unfocus = BooleanProperty(True)
+    '''If True, the :meth:`TextInput.on_text_validate` event will unfocus the
+    widget, therefore make it stop listening to the keyboard. When disabled,
+    the :meth:`TextInput.on_text_validate` event can be fired multiple times
+    as the result of TextInput keeping the focus enabled.
+
+    .. versionadded:: 1.10.1
+
+    :attr:`text_validate_unfocus` is
+    a :class:`~kivy.properties.BooleanProperty` and defaults to True.
+    '''
+
+    multiline = BooleanProperty(True)
+    '''If True, the widget will be able show multiple lines of text. If False,
+    the "enter" keypress will defocus the textinput instead of adding a new
+    line.
+
+    :attr:`multiline` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    do_wrap = BooleanProperty(True)
+    '''If True, and the text is multiline, then lines larger than the width of
+    the widget will wrap around to the next line, avoiding the need for
+    horizontal scrolling. Disabling this option ensure one line is always
+    displayed as one line.
+
+    :attr:`do_wrap` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to True.
+
+    versionadded:: 2.1.0
+    '''
+
+    password = BooleanProperty(False)
+    '''If True, the widget will display its characters as the character
+    set in :attr:`password_mask`.
+
+    .. versionadded:: 1.2.0
+
+    :attr:`password` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    password_mask = StringProperty('*')
+    '''Sets the character used to mask the text when :attr:`password` is True.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`password_mask` is a :class:`~kivy.properties.StringProperty` and
+    defaults to `'*'`.
+    '''
+
+    cursor_blink = BooleanProperty(True)
+    '''This property is used to set whether the graphic cursor should blink
+    or not.
+
+    .. versionchanged:: 1.10.1
+        `cursor_blink` has been refactored to enable switching the blinking
+        on/off and the previous behavior has been moved to a private
+        `_cursor_blink` property. The previous default value `False` has been
+        changed to `True`.
+
+    :attr:`cursor_blink` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    def _get_cursor(self):
+        return self._cursor
+
+    def _set_cursor(self, pos):
+        if not self._lines:
+            self._trigger_refresh_text()
+            return
+        l = self._lines
+        cr = boundary(pos[1], 0, len(l) - 1)
+        cc = boundary(pos[0], 0, len(l[cr]))
+        cursor = cc, cr
+
+        # adjust scrollview to ensure that the cursor will be always inside our
+        # viewport.
+        self._adjust_viewport(cc, cr)
+
+        if self._cursor == cursor:
+            return
+
+        self._cursor = cursor
+        return True
+
+    @triggered(timeout=-1)
+    def _adjust_viewport(self, cc, cr):
+        padding_left = self.padding[0]
+        padding_right = self.padding[2]
+        viewport_width = self.width - padding_left - padding_right
+        sx = self.scroll_x
+        base_dir = self.base_direction or self._resolved_base_dir
+        auto_halign_r = (
+            self.halign == 'auto'
+            and base_dir
+            and 'rtl' in base_dir
+        )
+
+        offset = self.cursor_offset()
+        row_width = self._get_row_width(self.cursor_row)
+
+        # if offset is outside the current bounds, readjust
+        if offset - sx >= viewport_width:
+            self.scroll_x = offset - viewport_width
+        elif offset < sx + 1:
+            self.scroll_x = offset
+
+        # Avoid right/center horizontal alignment issues if the viewport is at
+        # the end of the line, if not multiline.
+        viewport_scroll_x = row_width - viewport_width
+        if (
+            not self.multiline
+            and offset >= viewport_scroll_x
+            and self.scroll_x >= viewport_scroll_x
+            and (
+                self.halign == "center"
+                or self.halign == "right"
+                or auto_halign_r
+            )
+        ):
+            self.scroll_x = max(0, viewport_scroll_x)
+
+        # do the same for Y
+        # this algo try to center the cursor as much as possible
+        dy = self.line_height + self.line_spacing
+        offsety = cr * dy
+
+        padding_top = self.padding[1]
+        padding_bottom = self.padding[3]
+        viewport_height = self.height - padding_top - padding_bottom - dy
+
+        sy = self.scroll_y
+        if offsety > viewport_height + sy:
+            self.scroll_y = offsety - viewport_height
+        elif offsety < sy:
+            self.scroll_y = offsety
+
+    cursor = AliasProperty(_get_cursor, _set_cursor)
+    '''Tuple of (col, row) values indicating the current cursor position.
+    You can set a new (col, row) if you want to move the cursor. The scrolling
+    area will be automatically updated to ensure that the cursor is
+    visible inside the viewport.
+
+    :attr:`cursor` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    def _get_cursor_col(self):
+        return self._cursor[0]
+
+    cursor_col = AliasProperty(_get_cursor_col, None, bind=('cursor', ))
+    '''Current column of the cursor.
+
+    :attr:`cursor_col` is an :class:`~kivy.properties.AliasProperty` to
+    cursor[0], read-only.
+    '''
+
+    def _get_cursor_row(self):
+        return self._cursor[1]
+
+    cursor_row = AliasProperty(_get_cursor_row, None, bind=('cursor', ))
+    '''Current row of the cursor.
+
+    :attr:`cursor_row` is an :class:`~kivy.properties.AliasProperty` to
+    cursor[1], read-only.
+    '''
+
+    cursor_pos = AliasProperty(_get_cursor_pos, None,
+                               bind=('cursor', 'padding', 'pos', 'size',
+                                     'focus', 'scroll_x', 'scroll_y',
+                                     'line_height', 'line_spacing'),
+                               cache=False)
+    '''Current position of the cursor, in (x, y).
+
+    :attr:`cursor_pos` is an :class:`~kivy.properties.AliasProperty`,
+    read-only.
+    '''
+
+    cursor_color = ColorProperty([1, 0, 0, 1])
+    '''Current color of the cursor, in (r, g, b, a) format.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`cursor_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 0, 0, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    cursor_width = NumericProperty('1sp')
+    '''Current width of the cursor.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`cursor_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to '1sp'.
+    '''
+
+    line_height = NumericProperty(1)
+    '''Height of a line. This property is automatically computed from the
+    :attr:`font_name`, :attr:`font_size`. Changing the line_height will have
+    no impact.
+
+    .. note::
+
+        :attr:`line_height` is the height of a single line of text.
+        Use :attr:`minimum_height`, which also includes padding, to
+        get the height required to display the text properly.
+
+    :attr:`line_height` is a :class:`~kivy.properties.NumericProperty`,
+    read-only.
+    '''
+
+    tab_width = NumericProperty(4)
+    '''By default, each tab will be replaced by four spaces on the text
+    input widget. You can set a lower or higher value.
+
+    :attr:`tab_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 4.
+    '''
+
+    padding_x = VariableListProperty([0, 0], length=2, deprecated=True)
+    '''Horizontal padding of the text: [padding_left, padding_right].
+
+    padding_x also accepts a one argument form [padding_horizontal].
+
+    :attr:`padding_x` is a :class:`~kivy.properties.VariableListProperty` and
+    defaults to [0, 0]. This might be changed by the current theme.
+
+    .. deprecated:: 1.7.0
+        Use :attr:`padding` instead.
+    '''
+
+    def on_padding_x(self, instance, value):
+        self.padding[0] = value[0]
+        self.padding[2] = value[1]
+
+    padding_y = VariableListProperty([0, 0], length=2, deprecated=True)
+    '''Vertical padding of the text: [padding_top, padding_bottom].
+
+    padding_y also accepts a one argument form [padding_vertical].
+
+    :attr:`padding_y` is a :class:`~kivy.properties.VariableListProperty` and
+    defaults to [0, 0]. This might be changed by the current theme.
+
+    .. deprecated:: 1.7.0
+        Use :attr:`padding` instead.
+    '''
+
+    def on_padding_y(self, instance, value):
+        self.padding[1] = value[0]
+        self.padding[3] = value[1]
+
+    padding = VariableListProperty([6, 6, 6, 6])
+    '''Padding of the text: [padding_left, padding_top, padding_right,
+    padding_bottom].
+
+    padding also accepts a two argument form [padding_horizontal,
+    padding_vertical] and a one argument form [padding].
+
+    .. versionchanged:: 1.7.0
+        Replaced AliasProperty with VariableListProperty.
+
+    :attr:`padding` is a :class:`~kivy.properties.VariableListProperty` and
+    defaults to [6, 6, 6, 6].
+    '''
+
+    halign = OptionProperty('auto', options=['left', 'center', 'right',
+                            'auto'])
+    '''Horizontal alignment of the text.
+
+    :attr:`halign` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to 'auto'. Available options are : auto, left, center and right.
+    Auto will attempt to autodetect horizontal alignment for RTL text (Pango
+    only), otherwise it behaves like `left`.
+
+    .. versionadded:: 1.10.1
+    '''
+
+    scroll_x = NumericProperty(0)
+    '''X scrolling value of the viewport. The scrolling is automatically
+    updated when the cursor is moved or text changed. If there is no
+    user input, the scroll_x and scroll_y properties may be changed.
+
+    :attr:`scroll_x` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    scroll_y = NumericProperty(0)
+    '''Y scrolling value of the viewport. See :attr:`scroll_x` for more
+    information.
+
+    :attr:`scroll_y` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    selection_color = ColorProperty([0.1843, 0.6549, 0.8313, .5])
+    '''Current color of the selection, in (r, g, b, a) format.
+
+    .. warning::
+
+        The color should always have an "alpha" component less than 1
+        since the selection is drawn after the text.
+
+    :attr:`selection_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [0.1843, 0.6549, 0.8313, .5].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    border = ListProperty([4, 4, 4, 4])
+    '''Border used for :class:`~kivy.graphics.vertex_instructions.BorderImage`
+    graphics instruction. Used with :attr:`background_normal` and
+    :attr:`background_active`. Can be used for a custom background.
+
+    .. versionadded:: 1.4.1
+
+    It must be a list of four values: (bottom, right, top, left). Read the
+    BorderImage instruction for more information about how to use it.
+
+    :attr:`border` is a :class:`~kivy.properties.ListProperty` and defaults
+    to (4, 4, 4, 4).
+    '''
+
+    background_normal = StringProperty(
+        'atlas://data/images/defaulttheme/textinput')
+    '''Background image of the TextInput when it's not in focus.
+
+    .. versionadded:: 1.4.1
+
+    :attr:`background_normal` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/textinput'.
+    '''
+
+    background_disabled_normal = StringProperty(
+        'atlas://data/images/defaulttheme/textinput_disabled')
+    '''Background image of the TextInput when disabled.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background_disabled_normal` is a
+    :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/textinput_disabled'.
+    '''
+
+    background_active = StringProperty(
+        'atlas://data/images/defaulttheme/textinput_active')
+    '''Background image of the TextInput when it's in focus.
+
+    .. versionadded:: 1.4.1
+
+    :attr:`background_active` is a
+    :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/textinput_active'.
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''Current color of the background, in (r, g, b, a) format.
+
+    .. versionadded:: 1.2.0
+
+    :attr:`background_color` is a :class:`~kivy.properties.ColorProperty`
+    and defaults to [1, 1, 1, 1] (white).
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    foreground_color = ColorProperty([0, 0, 0, 1])
+    '''Current color of the foreground, in (r, g, b, a) format.
+
+    .. versionadded:: 1.2.0
+
+    :attr:`foreground_color` is a :class:`~kivy.properties.ColorProperty`
+    and defaults to [0, 0, 0, 1] (black).
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    disabled_foreground_color = ColorProperty([0, 0, 0, .5])
+    '''Current color of the foreground when disabled, in (r, g, b, a) format.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`disabled_foreground_color` is a
+    :class:`~kivy.properties.ColorProperty` and
+    defaults to [0, 0, 0, 5] (50% transparent black).
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    use_bubble = BooleanProperty(not _is_desktop)
+    '''Indicates whether the cut/copy/paste bubble is used.
+
+    .. versionadded:: 1.7.0
+
+    :attr:`use_bubble` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True on mobile OS's, False on desktop OS's.
+    '''
+
+    use_handles = BooleanProperty(not _is_desktop)
+    '''Indicates whether the selection handles are displayed.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`use_handles` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to True on mobile OS's, False on desktop OS's.
+    '''
+
+    scroll_from_swipe = BooleanProperty(not _is_desktop)
+    '''Allow to scroll the text using swipe gesture according to
+    :attr:`scroll_timeout` and :attr:`scroll_distance`.
+
+    .. versionadded:: 2.1.0
+
+    :attr:`scroll_from_swipe` is a BooleanProperty and defaults to True on
+    mobile OS’s, False on desktop OS’s.
+    '''
+
+    scroll_distance = NumericProperty(_scroll_distance)
+    '''Minimum distance to move before change from scroll to selection mode, in
+    pixels.
+    It is advisable that you base this value on the dpi of your target device's
+    screen.
+
+    .. versionadded:: 2.1.0
+
+    :attr:`scroll_distance` is a NumericProperty and defaults to  20 pixels.
+    '''
+
+    scroll_timeout = NumericProperty(_scroll_timeout)
+    '''Timeout allowed to trigger the :attr:`scroll_distance`, in milliseconds.
+    If the user has not moved :attr:`scroll_distance` within the timeout, the
+    scrolling will be disabled, and the selection mode will start.
+
+    .. versionadded:: 2.1.0
+
+    :attr:`scroll_timeout` is a NumericProperty and defaults to 250
+    milliseconds.
+    '''
+
+    def get_sel_from(self):
+        return self._selection_from
+
+    selection_from = AliasProperty(get_sel_from, None)
+    '''If a selection is in progress or complete, this property will represent
+    the cursor index where the selection started.
+
+    .. versionchanged:: 1.4.0
+        :attr:`selection_from` is an :class:`~kivy.properties.AliasProperty`
+        and defaults to None, readonly.
+    '''
+
+    def get_sel_to(self):
+        return self._selection_to
+
+    selection_to = AliasProperty(get_sel_to, None)
+    '''If a selection is in progress or complete, this property will represent
+    the cursor index where the selection started.
+
+    .. versionchanged:: 1.4.0
+        :attr:`selection_to` is an :class:`~kivy.properties.AliasProperty` and
+        defaults to None, readonly.
+    '''
+
+    selection_text = StringProperty(u'')
+    '''Current content selection.
+
+    :attr:`selection_text` is a :class:`~kivy.properties.StringProperty`
+    and defaults to '', readonly.
+    '''
+
+    def on_selection_text(self, instance, value):
+        if value:
+            if self.use_handles:
+                self._trigger_show_handles()
+            if CutBuffer and not self.password:
+                self._trigger_update_cutbuffer()
+
+    def _get_text(self):
+        flags = self._lines_flags
+        lines = self._lines
+        len_lines = len(lines)
+        less_flags = len(flags) < len_lines
+        if less_flags:
+            flags.append(1)
+        text = ''.join(
+            ('\n' if (flags[i] & FL_IS_LINEBREAK) else '') + lines[i]
+            for i in range(len_lines)
+        )
+        if less_flags:
+            flags.pop()
+        return text
+
+    def _set_text(self, text):
+        if isinstance(text, bytes):
+            text = text.decode('utf8')
+        if self.replace_crlf:
+            text = text.replace(u'\r\n', u'\n')
+        if self.text != text:
+            self._refresh_text(text)
+            self.cursor = self.get_cursor_from_index(len(text))
+
+    text = AliasProperty(_get_text, _set_text, bind=('_lines',), cache=True)
+    '''Text of the widget.
+
+    Creation of a simple hello world::
+
+        widget = TextInput(text='Hello world')
+
+    If you want to create the widget with an unicode string, use::
+
+        widget = TextInput(text=u'My unicode string')
+
+    :attr:`text` is an :class:`~kivy.properties.AliasProperty`.
+    '''
+
+    font_name = StringProperty(DEFAULT_FONT)
+    '''Filename of the font to use. The path can be absolute or relative.
+    Relative paths are resolved by the :func:`~kivy.resources.resource_find`
+    function.
+
+    .. warning::
+
+        Depending on your text provider, the font file may be ignored. However,
+        you can mostly use this without problems.
+
+        If the font used lacks the glyphs for the particular language/symbols
+        you are using, you will see '[]' blank box characters instead of the
+        actual glyphs. The solution is to use a font that has the glyphs you
+        need to display. For example, to display |unicodechar|, use a font like
+        freesans.ttf that has the glyph.
+
+        .. |unicodechar| image:: images/unicode-char.png
+
+    :attr:`font_name` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'Roboto'. This value is taken
+    from :class:`~kivy.config.Config`.
+    '''
+
+    font_size = NumericProperty('15sp')
+    '''Font size of the text in pixels.
+
+    :attr:`font_size` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 15 :attr:`~kivy.metrics.sp`.
+    '''
+
+    font_context = StringProperty(None, allownone=True)
+    '''Font context. `None` means the font is used in isolation, so you are
+    guaranteed to be drawing with the TTF file resolved by :attr:`font_name`.
+    Specifying a value here will load the font file into a named context,
+    enabling fallback between all fonts in the same context. If a font
+    context is set, you are not guaranteed that rendering will actually use
+    the specified TTF file for all glyphs (Pango will pick the one it
+    thinks is best).
+
+    If Kivy is linked against a system-wide installation of FontConfig,
+    you can load the system fonts by specifying a font context starting
+    with the special string `system://`. This will load the system
+    fontconfig configuration, and add your application-specific fonts on
+    top of it (this imposes a signifficant risk of family name collision,
+    Pango may not use your custom font file, but pick one from the system)
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. versionadded:: 1.10.1
+
+    :attr:`font_context` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    font_family = StringProperty(None, allownone=True)
+    '''Font family, this is only applicable when using :attr:`font_context`
+    option. The specified font family will be requested, but note that it may
+    not be available, or there could be multiple fonts registered with the
+    same family. The value can be a family name (string) available in the
+    font context (for example a system font in a `system://` context, or a
+    custom font file added using :class:`kivy.core.text.FontContextManager`).
+    If set to `None`, font selection is controlled by the :attr:`font_name`
+    setting.
+
+    .. note::
+        If using :attr:`font_name` to reference a custom font file, you
+        should leave this as `None`. The family name is managed automatically
+        in this case.
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. versionadded:: 1.10.1
+
+    :attr:`font_family` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    base_direction = OptionProperty(
+        None,
+        options=['ltr', 'rtl', 'weak_rtl', 'weak_ltr', None],
+        allownone=True
+    )
+    '''Base direction of text, this impacts horizontal alignment when
+    :attr:`halign` is `auto` (the default). Available options are: None,
+    "ltr" (left to right), "rtl" (right to left) plus "weak_ltr" and
+    "weak_rtl".
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. note::
+        Weak modes are currently not implemented in Kivy text layout, and
+        have the same effect as setting strong mode.
+
+    .. versionadded:: 1.10.1
+
+    :attr:`base_direction` is an :class:`~kivy.properties.OptionProperty` and
+    defaults to None (autodetect RTL if possible, otherwise LTR).
+    '''
+
+    text_language = StringProperty(None, allownone=True)
+    '''Language of the text, if None Pango will determine it from locale.
+    This is an RFC-3066 format language tag (as a string), for example
+    "en_US", "zh_CN", "fr" or "ja". This can impact font selection, metrics
+    and rendering. For example, the same bytes of text can look different
+    for `ur` and `ar` languages, though both use Arabic script.
+
+    .. note::
+        This feature requires the Pango text provider.
+
+    .. versionadded:: 1.10.1
+
+    :attr:`text_language` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+    '''
+
+    _hint_text = StringProperty('')
+
+    def _set_hint_text(self, value):
+        if isinstance(value, bytes):
+            value = value.decode('utf8')
+        self._hint_text = value
+
+    def _get_hint_text(self):
+        return self._hint_text
+
+    hint_text = AliasProperty(
+        _get_hint_text, _set_hint_text, bind=('_hint_text', ))
+    '''Hint text of the widget, shown if text is ''.
+
+    .. versionadded:: 1.6.0
+
+    .. versionchanged:: 1.10.0
+        The property is now an AliasProperty and byte values are decoded to
+        strings. The hint text will stay visible when the widget is focused.
+
+    :attr:`hint_text` a :class:`~kivy.properties.AliasProperty` and defaults
+    to ''.
+    '''
+
+    hint_text_color = ColorProperty([0.5, 0.5, 0.5, 1.0])
+    '''Current color of the hint_text text, in (r, g, b, a) format.
+
+    .. versionadded:: 1.6.0
+
+    :attr:`hint_text_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [0.5, 0.5, 0.5, 1.0] (grey).
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    auto_indent = BooleanProperty(False)
+    '''Automatically indent multiline text.
+
+    .. versionadded:: 1.7.0
+
+    :attr:`auto_indent` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    replace_crlf = BooleanProperty(True)
+    '''Automatically replace CRLF with LF.
+
+    .. versionadded:: 1.9.1
+
+    :attr:`replace_crlf` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    allow_copy = BooleanProperty(True)
+    '''Decides whether to allow copying the text.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`allow_copy` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to True.
+    '''
+
+    def _get_min_height(self):
+        return (
+            len(self._lines) * (self.line_height + self.line_spacing)
+            + self.padding[1]
+            + self.padding[3]
+        )
+
+    minimum_height = AliasProperty(
+        _get_min_height,
+        bind=(
+            '_lines', 'line_spacing', 'padding', 'font_size', 'font_name',
+            'password', 'font_context', 'hint_text', 'line_height'
+        ),
+        cache=True
+    )
+    '''Minimum height of the content inside the TextInput.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`minimum_height` is a readonly
+    :class:`~kivy.properties.AliasProperty`.
+
+    .. warning::
+        :attr:`minimum_width` is calculated based on :attr:`width` therefore
+        code like this will lead to an infinite loop::
+
+            <FancyTextInput>:
+                height: self.minimum_height
+                width: self.height
+    '''
+
+    line_spacing = NumericProperty(0)
+    '''Space taken up between the lines.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`line_spacing` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    input_filter = ObjectProperty(None, allownone=True)
+    ''' Filters the input according to the specified mode, if not None. If
+    None, no filtering is applied.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`input_filter` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to `None`. Can be one of `None`, `'int'` (string), or `'float'`
+    (string), or a callable. If it is `'int'`, it will only accept numbers.
+    If it is `'float'` it will also accept a single period. Finally, if it is
+    a callable it will be called with two parameters; the string to be added
+    and a bool indicating whether the string is a result of undo (True). The
+    callable should return a new substring that will be used instead.
+    '''
+
+    handle_image_middle = StringProperty(
+        'atlas://data/images/defaulttheme/selector_middle')
+    '''Image used to display the middle handle on the TextInput for cursor
+    positioning.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`handle_image_middle` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/selector_middle'.
+    '''
+
+    def on_handle_image_middle(self, instance, value):
+        if self._handle_middle:
+            self._handle_middle.source = value
+
+    handle_image_left = StringProperty(
+        'atlas://data/images/defaulttheme/selector_left')
+    '''Image used to display the Left handle on the TextInput for selection.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`handle_image_left` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/selector_left'.
+    '''
+
+    def on_handle_image_left(self, instance, value):
+        if self._handle_left:
+            self._handle_left.source = value
+
+    handle_image_right = StringProperty(
+        'atlas://data/images/defaulttheme/selector_right')
+    '''Image used to display the Right handle on the TextInput for selection.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`handle_image_right` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    'atlas://data/images/defaulttheme/selector_right'.
+    '''
+
+    def on_handle_image_right(self, instance, value):
+        if self._handle_right:
+            self._handle_right.source = value
+
+    write_tab = BooleanProperty(True)
+    '''Whether the tab key should move focus to the next widget or if it should
+    enter a tab in the :class:`TextInput`. If `True` a tab will be written,
+    otherwise, focus will move to the next widget.
+
+    .. versionadded:: 1.9.0
+
+    :attr:`write_tab` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to `True`.
+    '''
+
+
+if __name__ == '__main__':
+    from textwrap import dedent
+    from kivy.app import App
+    from kivy.uix.boxlayout import BoxLayout
+    from kivy.lang import Builder
+
+    KV = dedent(r'''
+    #:set font_size '20dp'
+
+    BoxLayout:
+        orientation: 'vertical'
+        padding: '20dp'
+        spacing: '10dp'
+        TextInput:
+            font_size: font_size
+            size_hint_y: None
+            height: self.minimum_height
+            multiline: False
+            text: 'monoline'
+
+        TextInput:
+            size_hint_y: None
+            font_size: font_size
+            height: self.minimum_height
+            multiline: False
+            password: True
+            password_mask: '•'
+            text: 'password'
+
+        TextInput:
+            font_size: font_size
+            size_hint_y: None
+            height: self.minimum_height
+            multiline: False
+            readonly: True
+            text: 'readonly'
+
+        TextInput:
+            font_size: font_size
+            size_hint_y: None
+            height: self.minimum_height
+            multiline: False
+            disabled: True
+            text: 'disabled'
+
+        TextInput:
+            font_size: font_size
+            hint_text: 'normal with hint text'
+
+        TextInput:
+            font_size: font_size
+            text: 'default'
+
+        TextInput:
+            font_size: font_size
+            text: 'bubble & handles'
+            use_bubble: True
+            use_handles: True
+
+        TextInput:
+            font_size: font_size
+            text: 'no wrap'
+            do_wrap: False
+
+        TextInput:
+            font_size: font_size
+            text: 'multiline\nreadonly'
+            disabled: app.time % 5 < 2.5
+    ''')
+
+    class TextInputApp(App):
+        time = NumericProperty()
+
+        def build(self):
+            Clock.schedule_interval(self.update_time, 0)
+            return Builder.load_string(KV)
+
+        def update_time(self, dt):
+            self.time += dt
+
+    TextInputApp().run()
diff --git a/kivy/uix/togglebutton.py b/kivy/uix/togglebutton.py
new file mode 100644
index 0000000..d066207
--- /dev/null
+++ b/kivy/uix/togglebutton.py
@@ -0,0 +1,37 @@
+'''
+Toggle button
+=============
+
+.. image:: images/togglebutton.jpg
+    :align: right
+
+The :class:`ToggleButton` widget acts like a checkbox. When you touch or click
+it, the state toggles between 'normal' and 'down' (as opposed to a
+:class:`Button` that is only 'down' as long as it is pressed).
+
+Toggle buttons can also be grouped to make radio buttons - only one button in
+a group can be in a 'down' state. The group name can be a string or any other
+hashable Python object::
+
+    btn1 = ToggleButton(text='Male', group='sex',)
+    btn2 = ToggleButton(text='Female', group='sex', state='down')
+    btn3 = ToggleButton(text='Mixed', group='sex')
+
+Only one of the buttons can be 'down'/checked at the same time.
+
+To configure the ToggleButton, you can use the same properties that you can use
+for a :class:`~kivy.uix.button.Button` class.
+
+'''
+
+__all__ = ('ToggleButton', )
+
+from kivy.uix.button import Button
+from kivy.uix.behaviors import ToggleButtonBehavior
+
+
+class ToggleButton(ToggleButtonBehavior, Button):
+    '''Toggle button class, see module documentation for more information.
+    '''
+
+    pass
diff --git a/kivy/uix/treeview.py b/kivy/uix/treeview.py
new file mode 100644
index 0000000..26a5da7
--- /dev/null
+++ b/kivy/uix/treeview.py
@@ -0,0 +1,665 @@
+'''
+Tree View
+=========
+
+.. image:: images/treeview.png
+    :align: right
+
+.. versionadded:: 1.0.4
+
+
+:class:`TreeView` is a widget used to represent a tree structure. It is
+currently very basic, supporting a minimal feature set.
+
+Introduction
+------------
+
+A :class:`TreeView` is populated with :class:`TreeViewNode` instances, but you
+cannot use a :class:`TreeViewNode` directly. You must combine it with another
+widget, such as :class:`~kivy.uix.label.Label`,
+:class:`~kivy.uix.button.Button` or even your own widget. The TreeView
+always creates a default root node, based on :class:`TreeViewLabel`.
+
+:class:`TreeViewNode` is a class object containing needed properties for
+serving as a tree node. Extend :class:`TreeViewNode` to create custom node
+types for use with a :class:`TreeView`.
+
+For constructing your own subclass, follow the pattern of TreeViewLabel which
+combines a Label and a TreeViewNode, producing a :class:`TreeViewLabel` for
+direct use in a TreeView instance.
+
+To use the TreeViewLabel class, you could create two nodes directly attached
+to root::
+
+    tv = TreeView()
+    tv.add_node(TreeViewLabel(text='My first item'))
+    tv.add_node(TreeViewLabel(text='My second item'))
+
+Or, create two nodes attached to a first::
+
+    tv = TreeView()
+    n1 = tv.add_node(TreeViewLabel(text='Item 1'))
+    tv.add_node(TreeViewLabel(text='SubItem 1'), n1)
+    tv.add_node(TreeViewLabel(text='SubItem 2'), n1)
+
+If you have a large tree structure, perhaps you would need a utility function
+to populate the tree view::
+
+    def populate_tree_view(tree_view, parent, node):
+        if parent is None:
+            tree_node = tree_view.add_node(TreeViewLabel(text=node['node_id'],
+                                                         is_open=True))
+        else:
+            tree_node = tree_view.add_node(TreeViewLabel(text=node['node_id'],
+                                                         is_open=True), parent)
+
+        for child_node in node['children']:
+            populate_tree_view(tree_view, tree_node, child_node)
+
+
+    tree = {'node_id': '1',
+            'children': [{'node_id': '1.1',
+                          'children': [{'node_id': '1.1.1',
+                                        'children': [{'node_id': '1.1.1.1',
+                                                      'children': []}]},
+                                       {'node_id': '1.1.2',
+                                        'children': []},
+                                       {'node_id': '1.1.3',
+                                        'children': []}]},
+                          {'node_id': '1.2',
+                           'children': []}]}
+
+
+    class TreeWidget(FloatLayout):
+        def __init__(self, **kwargs):
+            super(TreeWidget, self).__init__(**kwargs)
+
+            tv = TreeView(root_options=dict(text='Tree One'),
+                          hide_root=False,
+                          indent_level=4)
+
+            populate_tree_view(tv, None, tree)
+
+            self.add_widget(tv)
+
+The root widget in the tree view is opened by default and has text set as
+'Root'. If you want to change that, you can use the
+:attr:`TreeView.root_options`
+property. This will pass options to the root widget::
+
+    tv = TreeView(root_options=dict(text='My root label'))
+
+
+Creating Your Own Node Widget
+-----------------------------
+
+For a button node type, combine a :class:`~kivy.uix.button.Button` and a
+:class:`TreeViewNode` as follows::
+
+    class TreeViewButton(Button, TreeViewNode):
+        pass
+
+You must know that, for a given node, only the
+:attr:`~kivy.uix.widget.Widget.size_hint_x` will be honored. The allocated
+width for the node will depend of the current width of the TreeView and the
+level of the node. For example, if a node is at level 4, the width
+allocated will be:
+
+    treeview.width - treeview.indent_start - treeview.indent_level * node.level
+
+You might have some trouble with that. It is the developer's responsibility to
+correctly handle adapting the graphical representation nodes, if needed.
+'''
+
+from kivy.clock import Clock
+from kivy.uix.label import Label
+from kivy.uix.widget import Widget
+from kivy.properties import BooleanProperty, ListProperty, ObjectProperty, \
+    AliasProperty, NumericProperty, ReferenceListProperty, ColorProperty
+
+
+class TreeViewException(Exception):
+    '''Exception for errors in the :class:`TreeView`.
+    '''
+    pass
+
+
+class TreeViewNode(object):
+    '''TreeViewNode class, used to build a node class for a TreeView object.
+    '''
+
+    def __init__(self, **kwargs):
+        if self.__class__ is TreeViewNode:
+            raise TreeViewException('You cannot use directly TreeViewNode.')
+        super(TreeViewNode, self).__init__(**kwargs)
+
+    is_leaf = BooleanProperty(True)
+    '''Boolean to indicate whether this node is a leaf or not. Used to adjust
+    the graphical representation.
+
+    :attr:`is_leaf` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to True. It is automatically set to False when child is added.
+    '''
+
+    is_open = BooleanProperty(False)
+    '''Boolean to indicate whether this node is opened or not, in case there
+    are child nodes. This is used to adjust the graphical representation.
+
+    .. warning::
+
+        This property is automatically set by the :class:`TreeView`. You can
+        read but not write it.
+
+    :attr:`is_open` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    is_loaded = BooleanProperty(False)
+    '''Boolean to indicate whether this node is already loaded or not. This
+    property is used only if the :class:`TreeView` uses asynchronous loading.
+
+    :attr:`is_loaded` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    is_selected = BooleanProperty(False)
+    '''Boolean to indicate whether this node is selected or not. This is used
+    adjust the graphical representation.
+
+    .. warning::
+
+        This property is automatically set by the :class:`TreeView`. You can
+        read but not write it.
+
+    :attr:`is_selected` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    no_selection = BooleanProperty(False)
+    '''Boolean used to indicate whether selection of the node is allowed or
+     not.
+
+    :attr:`no_selection` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    nodes = ListProperty([])
+    '''List of nodes. The nodes list is different than the children list. A
+    node in the nodes list represents a node on the tree. An item in the
+    children list represents the widget associated with the node.
+
+    .. warning::
+
+        This property is automatically set by the :class:`TreeView`. You can
+        read but not write it.
+
+    :attr:`nodes` is a :class:`~kivy.properties.ListProperty` and defaults to
+    [].
+    '''
+
+    parent_node = ObjectProperty(None, allownone=True)
+    '''Parent node. This attribute is needed because the :attr:`parent` can be
+    None when the node is not displayed.
+
+    .. versionadded:: 1.0.7
+
+    :attr:`parent_node` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    level = NumericProperty(-1)
+    '''Level of the node.
+
+    :attr:`level` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to -1.
+    '''
+
+    color_selected = ColorProperty([.3, .3, .3, 1.])
+    '''Background color of the node when the node is selected.
+
+    :attr:`color_selected` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [.1, .1, .1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    odd = BooleanProperty(False)
+    '''
+    This property is set by the TreeView widget automatically and is read-only.
+
+    :attr:`odd` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    odd_color = ColorProperty([1., 1., 1., .0])
+    '''Background color of odd nodes when the node is not selected.
+
+    :attr:`odd_color` is a :class:`~kivy.properties.ColorProperty` and defaults
+    to [1., 1., 1., 0.].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    even_color = ColorProperty([0.5, 0.5, 0.5, 0.1])
+    '''Background color of even nodes when the node is not selected.
+
+    :attr:`bg_color` is a :class:`~kivy.properties.ColorProperty` and defaults
+    to [.5, .5, .5, .1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+
+class TreeViewLabel(Label, TreeViewNode):
+    '''Combines a :class:`~kivy.uix.label.Label` and a :class:`TreeViewNode` to
+    create a :class:`TreeViewLabel` that can be used as a text node in the
+    tree.
+
+    See module documentation for more information.
+    '''
+
+
+class TreeView(Widget):
+    '''TreeView class. See module documentation for more information.
+
+    :Events:
+        `on_node_expand`: (node, )
+            Fired when a node is being expanded
+        `on_node_collapse`: (node, )
+            Fired when a node is being collapsed
+    '''
+
+    __events__ = ('on_node_expand', 'on_node_collapse')
+
+    def __init__(self, **kwargs):
+        self._trigger_layout = Clock.create_trigger(self._do_layout, -1)
+        super(TreeView, self).__init__(**kwargs)
+        tvlabel = TreeViewLabel(text='Root', is_open=True, level=0)
+        for key, value in self.root_options.items():
+            setattr(tvlabel, key, value)
+        self._root = self.add_node(tvlabel, None)
+
+        trigger = self._trigger_layout
+        fbind = self.fbind
+        fbind('pos', trigger)
+        fbind('size', trigger)
+        fbind('indent_level', trigger)
+        fbind('indent_start', trigger)
+        trigger()
+
+    def add_node(self, node, parent=None):
+        '''Add a new node to the tree.
+
+        :Parameters:
+            `node`: instance of a :class:`TreeViewNode`
+                Node to add into the tree
+            `parent`: instance of a :class:`TreeViewNode`, defaults to None
+                Parent node to attach the new node. If `None`, it is added to
+                the :attr:`root` node.
+
+        :returns:
+            the node `node`.
+        '''
+        # check if the widget is "ok" for a node
+        if not isinstance(node, TreeViewNode):
+            raise TreeViewException(
+                'The node must be a subclass of TreeViewNode')
+        # create node
+        if parent is None and self._root:
+            parent = self._root
+        if parent:
+            parent.is_leaf = False
+            parent.nodes.append(node)
+            node.parent_node = parent
+            node.level = parent.level + 1
+        node.fbind('size', self._trigger_layout)
+        self._trigger_layout()
+        return node
+
+    def remove_node(self, node):
+        '''Removes a node from the tree.
+
+        .. versionadded:: 1.0.7
+
+        :Parameters:
+            `node`: instance of a :class:`TreeViewNode`
+                Node to remove from the tree. If `node` is :attr:`root`, it is
+                not removed.
+        '''
+        # check if the widget is "ok" for a node
+        if not isinstance(node, TreeViewNode):
+            raise TreeViewException(
+                'The node must be a subclass of TreeViewNode')
+        parent = node.parent_node
+        if parent is not None:
+            if node == self._selected_node:
+                node.is_selected = False
+                self._selected_node = None
+            nodes = parent.nodes
+            if node in nodes:
+                nodes.remove(node)
+            parent.is_leaf = not bool(len(nodes))
+            node.parent_node = None
+            node.funbind('size', self._trigger_layout)
+            self._trigger_layout()
+
+    def on_node_expand(self, node):
+        pass
+
+    def on_node_collapse(self, node):
+        pass
+
+    def select_node(self, node):
+        '''Select a node in the tree.
+        '''
+        if node.no_selection:
+            return
+        if self._selected_node:
+            self._selected_node.is_selected = False
+        node.is_selected = True
+        self._selected_node = node
+
+    def deselect_node(self, *args):
+        '''Deselect any selected node.
+
+        .. versionadded:: 1.10.0
+        '''
+        if self._selected_node:
+            self._selected_node.is_selected = False
+            self._selected_node = None
+
+    def toggle_node(self, node):
+        '''Toggle the state of the node (open/collapsed).
+        '''
+        node.is_open = not node.is_open
+        if node.is_open:
+            if self.load_func and not node.is_loaded:
+                self._do_node_load(node)
+            self.dispatch('on_node_expand', node)
+        else:
+            self.dispatch('on_node_collapse', node)
+        self._trigger_layout()
+
+    def get_node_at_pos(self, pos):
+        '''Get the node at the position (x, y).
+        '''
+        x, y = pos
+        for node in self.iterate_open_nodes(self.root):
+            if self.x <= x <= self.right and \
+               node.y <= y <= node.top:
+                return node
+
+    def iterate_open_nodes(self, node=None):
+        '''Generator to iterate over all the expended nodes starting from
+        `node` and down. If `node` is `None`, the generator start with
+        :attr:`root`.
+
+        To get all the open nodes::
+
+            treeview = TreeView()
+            # ... add nodes ...
+            for node in treeview.iterate_open_nodes():
+                print(node)
+
+        '''
+        if not node:
+            node = self.root
+        if self.hide_root and node is self.root:
+            pass
+        else:
+            yield node
+        if not node.is_open:
+            return
+        f = self.iterate_open_nodes
+        for cnode in node.nodes:
+            for ynode in f(cnode):
+                yield ynode
+
+    def iterate_all_nodes(self, node=None):
+        '''Generator to iterate over all nodes from `node` and down whether
+        expanded or not. If `node` is `None`, the generator start with
+        :attr:`root`.
+        '''
+        if not node:
+            node = self.root
+        yield node
+        f = self.iterate_all_nodes
+        for cnode in node.nodes:
+            for ynode in f(cnode):
+                yield ynode
+
+    #
+    # Private
+    #
+    def on_load_func(self, instance, value):
+        if value:
+            Clock.schedule_once(self._do_initial_load)
+
+    def _do_initial_load(self, *largs):
+        if not self.load_func:
+            return
+        self._do_node_load(None)
+
+    def _do_node_load(self, node):
+        gen = self.load_func(self, node)
+        if node:
+            node.is_loaded = True
+        if not gen:
+            return
+        for cnode in gen:
+            self.add_node(cnode, node)
+
+    def on_root_options(self, instance, value):
+        if not self.root:
+            return
+        for key, value in value.items():
+            setattr(self.root, key, value)
+
+    def _do_layout(self, *largs):
+        self.clear_widgets()
+        # display only the one who are is_open
+        self._do_open_node(self.root)
+        # now do layout
+        self._do_layout_node(self.root, 0, self.top)
+        # now iterate for calculating minimum size
+        min_width = min_height = 0
+        for count, node in enumerate(self.iterate_open_nodes(self.root)):
+            node.odd = False if count % 2 else True
+            min_width = max(min_width, node.right - self.x)
+            min_height += node.height
+        self.minimum_size = (min_width, min_height)
+
+    def _do_open_node(self, node):
+        if self.hide_root and node is self.root:
+            height = 0
+        else:
+            self.add_widget(node)
+            height = node.height
+            if not node.is_open:
+                return height
+        for cnode in node.nodes:
+            height += self._do_open_node(cnode)
+        return height
+
+    def _do_layout_node(self, node, level, y):
+        if self.hide_root and node is self.root:
+            level -= 1
+        else:
+            node.x = self.x + self.indent_start + level * self.indent_level
+            node.top = y
+            if node.size_hint_x:
+                node.width = (self.width - (node.x - self.x)) \
+                    * node.size_hint_x
+            y -= node.height
+            if not node.is_open:
+                return y
+        for cnode in node.nodes:
+            y = self._do_layout_node(cnode, level + 1, y)
+        return y
+
+    def on_touch_down(self, touch):
+        node = self.get_node_at_pos(touch.pos)
+        if not node:
+            return
+        if node.disabled:
+            return
+        # toggle node or selection ?
+        if node.x - self.indent_start <= touch.x < node.x:
+            self.toggle_node(node)
+        elif node.x <= touch.x:
+            self.select_node(node)
+            node.dispatch('on_touch_down', touch)
+        return True
+
+    #
+    # Private properties
+    #
+    _root = ObjectProperty(None)
+
+    _selected_node = ObjectProperty(None, allownone=True)
+
+    #
+    # Properties
+    #
+
+    minimum_width = NumericProperty(0)
+    '''Minimum width needed to contain all children.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`minimum_width` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    minimum_height = NumericProperty(0)
+    '''Minimum height needed to contain all children.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`minimum_height` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 0.
+    '''
+
+    minimum_size = ReferenceListProperty(minimum_width, minimum_height)
+    '''Minimum size needed to contain all children.
+
+    .. versionadded:: 1.0.9
+
+    :attr:`minimum_size` is a :class:`~kivy.properties.ReferenceListProperty`
+    of (:attr:`minimum_width`, :attr:`minimum_height`) properties.
+    '''
+
+    indent_level = NumericProperty('16dp')
+    '''Width used for the indentation of each level except the first level.
+
+    Computation of indent for each level of the tree is::
+
+        indent = indent_start + level * indent_level
+
+    :attr:`indent_level` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 16.
+    '''
+
+    indent_start = NumericProperty('24dp')
+    '''Indentation width of the level 0 / root node. This is mostly the initial
+    size to accommodate a tree icon (collapsed / expanded). See
+    :attr:`indent_level` for more information about the computation of level
+    indentation.
+
+    :attr:`indent_start` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 24.
+    '''
+
+    hide_root = BooleanProperty(False)
+    '''Use this property to show/hide the initial root node. If True, the root
+    node will be appear as a closed node.
+
+    :attr:`hide_root` is a :class:`~kivy.properties.BooleanProperty` and
+    defaults to False.
+    '''
+
+    def get_selected_node(self):
+        return self._selected_node
+
+    selected_node = AliasProperty(get_selected_node, None,
+                                  bind=('_selected_node', ))
+    '''Node selected by :meth:`TreeView.select_node` or by touch.
+
+    :attr:`selected_node` is a :class:`~kivy.properties.AliasProperty` and
+    defaults to None. It is read-only.
+    '''
+
+    def get_root(self):
+        return self._root
+
+    root = AliasProperty(get_root, None, bind=('_root', ))
+    '''Root node.
+
+    By default, the root node widget is a :class:`TreeViewLabel` with text
+    'Root'. If you want to change the default options passed to the widget
+    creation, use the :attr:`root_options` property::
+
+        treeview = TreeView(root_options={
+            'text': 'Root directory',
+            'font_size': 15})
+
+    :attr:`root_options` will change the properties of the
+    :class:`TreeViewLabel` instance. However, you cannot change the class used
+    for root node yet.
+
+    :attr:`root` is an :class:`~kivy.properties.AliasProperty` and defaults to
+    None. It is read-only. However, the content of the widget can be changed.
+    '''
+
+    root_options = ObjectProperty({})
+    '''Default root options to pass for root widget. See :attr:`root` property
+    for more information about the usage of root_options.
+
+    :attr:`root_options` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to {}.
+    '''
+
+    load_func = ObjectProperty(None)
+    '''Callback to use for asynchronous loading. If set, asynchronous loading
+    will be automatically done. The callback must act as a Python generator
+    function, using yield to send data back to the treeview.
+
+    The callback should be in the format::
+
+        def callback(treeview, node):
+            for name in ('Item 1', 'Item 2'):
+                yield TreeViewLabel(text=name)
+
+    :attr:`load_func` is a :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+
+    class TestApp(App):
+
+        def build(self):
+            tv = TreeView(hide_root=True)
+            add = tv.add_node
+            root = add(TreeViewLabel(text='Level 1, entry 1', is_open=True))
+            for x in range(5):
+                add(TreeViewLabel(text='Element %d' % x), root)
+            root2 = add(TreeViewLabel(text='Level 1, entry 2', is_open=False))
+            for x in range(24):
+                add(TreeViewLabel(text='Element %d' % x), root2)
+            for x in range(5):
+                add(TreeViewLabel(text='Element %d' % x), root)
+            root2 = add(TreeViewLabel(text='Element childs 2', is_open=False),
+                        root)
+            for x in range(24):
+                add(TreeViewLabel(text='Element %d' % x), root2)
+            return tv
+    TestApp().run()
diff --git a/kivy/uix/video.py b/kivy/uix/video.py
new file mode 100644
index 0000000..935dec7
--- /dev/null
+++ b/kivy/uix/video.py
@@ -0,0 +1,302 @@
+'''
+Video
+=====
+
+The :class:`Video` widget is used to display video files and streams.
+Depending on your Video core provider, platform, and plugins, you will
+be able to play different formats. For example, the pygame video
+provider only supports MPEG1 on Linux and OSX. GStreamer is more
+versatile, and can read many video containers and codecs such as MKV,
+OGV, AVI, MOV, FLV (if the correct gstreamer plugins are installed). Our
+:class:`~kivy.core.video.VideoBase` implementation is used under the
+hood.
+
+Video loading is asynchronous - many properties are not available until
+the video is loaded (when the texture is created)::
+
+    def on_position_change(instance, value):
+        print('The position in the video is', value)
+
+    def on_duration_change(instance, value):
+        print('The duration of the video is', value)
+
+    video = Video(source='PandaSneezes.avi')
+    video.bind(
+        position=on_position_change,
+        duration=on_duration_change
+    )
+
+One can define a preview image which gets displayed until the video is
+started/loaded by passing ``preview`` to the constructor::
+
+    video = Video(
+        source='PandaSneezes.avi',
+        preview='PandaSneezes_preview.png'
+    )
+
+One can display the placeholder image when the video stops by reacting on eos::
+
+    def on_eos_change(self, inst, val):
+        if val and self.preview:
+            self.set_texture_from_resource(self.preview)
+
+    video.bind(eos=on_eos_change)
+'''
+
+__all__ = ('Video', )
+
+from kivy.clock import Clock
+from kivy.uix.image import Image
+from kivy.core.video import Video as CoreVideo
+from kivy.resources import resource_find
+from kivy.properties import (BooleanProperty, NumericProperty, ObjectProperty,
+                             OptionProperty, StringProperty)
+
+
+class Video(Image):
+    '''Video class. See module documentation for more information.
+    '''
+
+    preview = StringProperty(None, allownone=True)
+    '''Filename / source of a preview image displayed before video starts.
+
+    :attr:`preview` is a :class:`~kivy.properties.StringProperty` and
+    defaults to None.
+
+    If set, it gets displayed until the video is loaded/started.
+
+    .. versionadded:: 2.1.0
+    '''
+
+    state = OptionProperty('stop', options=('play', 'pause', 'stop'))
+    '''String, indicates whether to play, pause, or stop the video::
+
+        # 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'
+
+    :attr:`state` is an :class:`~kivy.properties.OptionProperty` and defaults
+    to 'stop'.
+    '''
+
+    play = BooleanProperty(False, deprecated=True)
+    '''
+    .. deprecated:: 1.4.0
+        Use :attr:`state` instead.
+
+    Boolean, indicates whether the video is playing or not.
+    You can start/stop the video by setting this property::
+
+        # 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
+
+    :attr:`play` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+
+    .. deprecated:: 1.4.0
+        Use :attr:`state` instead.
+    '''
+
+    eos = BooleanProperty(False)
+    '''Boolean, indicates whether the video has finished playing or not
+    (reached the end of the stream).
+
+    :attr:`eos` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.
+    '''
+
+    loaded = BooleanProperty(False)
+    '''Boolean, indicates whether the video is loaded and ready for playback
+    or not.
+
+    .. versionadded:: 1.6.0
+
+    :attr:`loaded` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    position = NumericProperty(-1)
+    '''Position of the video between 0 and :attr:`duration`. The position
+    defaults to -1 and is set to a real position when the video is loaded.
+
+    :attr:`position` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to -1.
+    '''
+
+    duration = NumericProperty(-1)
+    '''Duration of the video. The duration defaults to -1, and is set to a real
+    duration when the video is loaded.
+
+    :attr:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to -1.
+    '''
+
+    volume = NumericProperty(1.)
+    '''Volume of the video, in the range 0-1. 1 means full volume, 0
+    means mute.
+
+    :attr:`volume` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.
+    '''
+
+    options = ObjectProperty({})
+    '''Options to pass at Video core object creation.
+
+    .. versionadded:: 1.0.4
+
+    :attr:`options` is an :class:`kivy.properties.ObjectProperty` and defaults
+    to {}.
+    '''
+
+    _video_load_event = None
+
+    def __init__(self, **kwargs):
+        self._video = None
+        super(Video, self).__init__(**kwargs)
+        self.fbind('source', self._trigger_video_load)
+
+        if "eos" in kwargs:
+            self.options["eos"] = kwargs["eos"]
+        if self.source:
+            self._trigger_video_load()
+
+    def texture_update(self, *largs):
+        if self.preview:
+            self.set_texture_from_resource(self.preview)
+        else:
+            self.set_texture_from_resource(self.source)
+
+    def seek(self, percent, precise=True):
+        '''Change the position to a percentage (strictly, a proportion)
+           of duration.
+
+        :Parameters:
+            `percent`: float or int
+                Position to seek as a proportion of the total duration,
+                must be between 0-1.
+            `precise`: bool, defaults to True
+                Precise seeking is slower, but seeks to exact requested
+                percent.
+
+        .. warning::
+            Calling seek() before the video is loaded has no effect.
+
+        .. versionadded:: 1.2.0
+
+        .. versionchanged:: 1.10.1
+            The `precise` keyword argument has been added.
+        '''
+        if self._video is None:
+            raise Exception('Video not loaded.')
+        self._video.seek(percent, precise=precise)
+
+    def _trigger_video_load(self, *largs):
+        ev = self._video_load_event
+        if ev is None:
+            ev = self._video_load_event = Clock.schedule_once(
+                self._do_video_load, -1)
+        ev()
+
+    def _do_video_load(self, *largs):
+        if CoreVideo is None:
+            return
+        self.unload()
+        if not self.source:
+            self._video = None
+            self.texture = None
+        else:
+            filename = self.source
+            # Check if filename is not url
+            if '://' not in filename:
+                filename = resource_find(filename)
+            self._video = CoreVideo(filename=filename, **self.options)
+            self._video.volume = self.volume
+            self._video.bind(on_load=self._on_load,
+                             on_frame=self._on_video_frame,
+                             on_eos=self._on_eos)
+            if self.state == 'play' or self.play:
+                self._video.play()
+            self.duration = 1.
+            self.position = 0.
+
+    def on_play(self, instance, value):
+        value = 'play' if value else 'stop'
+        return self.on_state(instance, value)
+
+    def on_state(self, instance, value):
+        if not self._video:
+            return
+        if value == 'play':
+            if self.eos:
+                self._video.stop()
+                self._video.position = 0.
+            self.eos = False
+            self._video.play()
+        elif value == 'pause':
+            self._video.pause()
+        else:
+            self._video.stop()
+            self._video.position = 0
+
+    def _on_video_frame(self, *largs):
+        video = self._video
+        if not video:
+            return
+        self.duration = video.duration
+        self.position = video.position
+        self.texture = video.texture
+        self.canvas.ask_update()
+
+    def _on_eos(self, *largs):
+        if not self._video or self._video.eos != 'loop':
+            self.state = 'stop'
+            self.eos = True
+
+    def _on_load(self, *largs):
+        self.loaded = True
+        self._on_video_frame(largs)
+
+    def on_volume(self, instance, value):
+        if self._video:
+            self._video.volume = value
+
+    def unload(self):
+        '''Unload the video. The playback will be stopped.
+
+        .. versionadded:: 1.8.0
+        '''
+        if self._video:
+            self._video.stop()
+            self._video.unload()
+            self._video = None
+        self.loaded = False
+
+
+if __name__ == '__main__':
+    from kivy.app import App
+    import sys
+
+    if len(sys.argv) != 2:
+        print("usage: %s file" % sys.argv[0])
+        sys.exit(1)
+
+    class VideoApp(App):
+        def build(self):
+            self.v = Video(source=sys.argv[1], state='play')
+            self.v.bind(state=self.replay)
+            return self.v
+
+        def replay(self, *args):
+            if self.v.state == 'stop':
+                self.v.state = 'play'
+
+    VideoApp().run()
diff --git a/kivy/uix/videoplayer.py b/kivy/uix/videoplayer.py
new file mode 100644
index 0000000..ec0a45e
--- /dev/null
+++ b/kivy/uix/videoplayer.py
@@ -0,0 +1,697 @@
+'''
+Video player
+============
+
+.. versionadded:: 1.2.0
+
+The video player widget can be used to play video and let the user control the
+play/pausing, volume and position. The widget cannot be customized much because
+of the complex assembly of numerous base widgets.
+
+.. image:: images/videoplayer.jpg
+    :align: center
+
+Annotations
+-----------
+
+If you want to display text at a specific time and for a certain duration,
+consider annotations. An annotation file has a ".jsa" extension. The player
+will automatically load the associated annotation file if it exists.
+
+An annotation file is JSON-based, providing a list of label dictionary items.
+The key and value must match one of the :class:`VideoPlayerAnnotation` items.
+For example, here is a short version of a jsa file that you can find in
+`examples/widgets/cityCC0.jsa`::
+
+
+    [
+        {"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"}
+    ]
+
+For our cityCC0.mpg example, the result will be:
+
+.. image:: images/videoplayer-annotation.jpg
+    :align: center
+
+If you want to experiment with annotation files, test with::
+
+    python -m kivy.uix.videoplayer examples/widgets/cityCC0.mpg
+
+Fullscreen
+----------
+
+The video player can play the video in fullscreen, if
+:attr:`VideoPlayer.allow_fullscreen` is activated by a double-tap on
+the video. By default, if the video is smaller than the Window, it will be not
+stretched.
+
+You can allow stretching by passing custom options to a
+:class:`VideoPlayer` instance::
+
+    player = VideoPlayer(source='myvideo.avi', state='play',
+        options={'allow_stretch': True})
+
+End-of-stream behavior
+----------------------
+
+You can specify what happens when the video has finished playing by passing an
+`eos` (end of stream) directive to the underlying
+:class:`~kivy.core.video.VideoBase` class. `eos` can be one of 'stop', 'pause'
+or 'loop' and defaults to 'stop'. For example, in order to loop the video::
+
+    player = VideoPlayer(source='myvideo.avi', state='play',
+        options={'eos': 'loop'})
+
+.. note::
+
+    The `eos` property of the VideoBase class is a string specifying the
+    end-of-stream behavior. This property differs from the `eos`
+    properties of the :class:`VideoPlayer` and
+    :class:`~kivy.uix.video.Video` classes, whose `eos`
+    property is simply a boolean indicating that the end of the file has
+    been reached.
+
+'''
+
+__all__ = ('VideoPlayer', 'VideoPlayerAnnotation')
+
+from json import load
+from os.path import exists
+from kivy.properties import ObjectProperty, StringProperty, BooleanProperty, \
+    NumericProperty, DictProperty, OptionProperty
+from kivy.animation import Animation
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.progressbar import ProgressBar
+from kivy.uix.label import Label
+from kivy.uix.video import Video
+from kivy.uix.video import Image
+from kivy.factory import Factory
+from kivy.logger import Logger
+from kivy.clock import Clock
+
+
+class VideoPlayerVolume(Image):
+    video = ObjectProperty(None)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return False
+        touch.grab(self)
+        # save the current volume and delta to it
+        touch.ud[self.uid] = [self.video.volume, 0]
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is not self:
+            return
+        # calculate delta
+        dy = abs(touch.y - touch.oy)
+        if dy > 10:
+            dy = min(dy - 10, 100)
+            touch.ud[self.uid][1] = dy
+            self.video.volume = dy / 100.
+        return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+        dy = abs(touch.y - touch.oy)
+        if dy < 10:
+            if self.video.volume > 0:
+                self.video.volume = 0
+            else:
+                self.video.volume = 1.
+
+
+class VideoPlayerPlayPause(Image):
+    video = ObjectProperty(None)
+
+    def on_touch_down(self, touch):
+        '''.. versionchanged:: 1.4.0'''
+        if self.collide_point(*touch.pos):
+            if self.video.state == 'play':
+                self.video.state = 'pause'
+            else:
+                self.video.state = 'play'
+            return True
+
+
+class VideoPlayerStop(Image):
+    video = ObjectProperty(None)
+
+    def on_touch_down(self, touch):
+        if self.collide_point(*touch.pos):
+            self.video.state = 'stop'
+            self.video.position = 0
+            return True
+
+
+class VideoPlayerProgressBar(ProgressBar):
+    video = ObjectProperty(None)
+    seek = NumericProperty(None, allownone=True)
+    alpha = NumericProperty(1.)
+
+    def __init__(self, **kwargs):
+        super(VideoPlayerProgressBar, self).__init__(**kwargs)
+        self.bubble = Factory.Bubble(size=(50, 44))
+        self.bubble_label = Factory.Label(text='0:00')
+        self.bubble.add_widget(self.bubble_label)
+        self.add_widget(self.bubble)
+
+        update = self._update_bubble
+        fbind = self.fbind
+        fbind('pos', update)
+        fbind('size', update)
+        fbind('seek', update)
+
+    def on_video(self, instance, value):
+        self.video.bind(position=self._update_bubble,
+                        state=self._showhide_bubble)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return
+        self._show_bubble()
+        touch.grab(self)
+        self._update_seek(touch.x)
+        return True
+
+    def on_touch_move(self, touch):
+        if touch.grab_current is not self:
+            return
+        self._update_seek(touch.x)
+        return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is not self:
+            return
+        touch.ungrab(self)
+        if self.seek:
+            self.video.seek(self.seek)
+        self.seek = None
+        self._hide_bubble()
+        return True
+
+    def _update_seek(self, x):
+        if self.width == 0:
+            return
+        x = max(self.x, min(self.right, x)) - self.x
+        self.seek = x / float(self.width)
+
+    def _show_bubble(self):
+        self.alpha = 1
+        Animation.stop_all(self, 'alpha')
+
+    def _hide_bubble(self):
+        self.alpha = 1.
+        Animation(alpha=0, d=4, t='in_out_expo').start(self)
+
+    def on_alpha(self, instance, value):
+        self.bubble.background_color = (1, 1, 1, value)
+        self.bubble_label.color = (1, 1, 1, value)
+
+    def _update_bubble(self, *l):
+        seek = self.seek
+        if self.seek is None:
+            if self.video.duration == 0:
+                seek = 0
+            else:
+                seek = self.video.position / self.video.duration
+        # convert to minutes:seconds
+        d = self.video.duration * seek
+        minutes = int(d / 60)
+        seconds = int(d - (minutes * 60))
+        # fix bubble label & position
+        self.bubble_label.text = '%d:%02d' % (minutes, seconds)
+        self.bubble.center_x = self.x + seek * self.width
+        self.bubble.y = self.top
+
+    def _showhide_bubble(self, instance, value):
+        if value == 'play':
+            self._hide_bubble()
+        else:
+            self._show_bubble()
+
+
+class VideoPlayerPreview(FloatLayout):
+    source = ObjectProperty(None)
+    video = ObjectProperty(None)
+    click_done = BooleanProperty(False)
+
+    def on_touch_down(self, touch):
+        if self.collide_point(*touch.pos) and not self.click_done:
+            self.click_done = True
+            self.video.state = 'play'
+        return True
+
+
+class VideoPlayerAnnotation(Label):
+    '''Annotation class used for creating annotation labels.
+
+    Additional keys are available:
+
+    * bgcolor: [r, g, b, a] - background color of the text box
+    * bgsource: 'filename' - background image used for the background text box
+    * border: (n, e, s, w) - border used for the background image
+
+    '''
+    start = NumericProperty(0)
+    '''Start time of the annotation.
+
+    :attr:`start` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 0.
+    '''
+
+    duration = NumericProperty(1)
+    '''Duration of the annotation.
+
+    :attr:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+    '''
+
+    annotation = DictProperty({})
+
+    def on_annotation(self, instance, ann):
+        for key, value in ann.items():
+            setattr(self, key, value)
+
+
+class VideoPlayer(GridLayout):
+    '''VideoPlayer class. See module documentation for more information.
+    '''
+
+    source = StringProperty('')
+    '''Source of the video to read.
+
+    :attr:`source` is a :class:`~kivy.properties.StringProperty` and
+    defaults to ''.
+
+    .. versionchanged:: 1.4.0
+    '''
+
+    thumbnail = StringProperty('')
+    '''Thumbnail of the video to show. If None, VideoPlayer will try to find
+    the thumbnail from the :attr:`source` + '.png'.
+
+    :attr:`thumbnail` a :class:`~kivy.properties.StringProperty` and defaults
+    to ''.
+
+    .. versionchanged:: 1.4.0
+    '''
+
+    duration = NumericProperty(-1)
+    '''Duration of the video. The duration defaults to -1 and is set to the
+    real duration when the video is loaded.
+
+    :attr:`duration` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to -1.
+    '''
+
+    position = NumericProperty(0)
+    '''Position of the video between 0 and :attr:`duration`. The position
+    defaults to -1 and is set to the real position when the video is loaded.
+
+    :attr:`position` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to -1.
+    '''
+
+    volume = NumericProperty(1.0)
+    '''Volume of the video in the range 0-1. 1 means full volume and 0 means
+    mute.
+
+    :attr:`volume` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.
+    '''
+
+    state = OptionProperty('stop', options=('play', 'pause', 'stop'))
+    '''String, indicates whether to play, pause, or stop the video::
+
+        # start playing the video at creation
+        video = VideoPlayer(source='movie.mkv', state='play')
+
+        # create the video, and start later
+        video = VideoPlayer(source='movie.mkv')
+        # and later
+        video.state = 'play'
+
+    :attr:`state` is an :class:`~kivy.properties.OptionProperty` and defaults
+    to 'stop'.
+    '''
+
+    play = BooleanProperty(False, deprecated=True)
+    '''
+    .. deprecated:: 1.4.0
+        Use :attr:`state` instead.
+
+    Boolean, indicates whether the video is playing or not. You can start/stop
+    the video by setting this property::
+
+        # start playing the video at creation
+        video = VideoPlayer(source='movie.mkv', play=True)
+
+        # create the video, and start later
+        video = VideoPlayer(source='movie.mkv')
+        # and later
+        video.play = True
+
+    :attr:`play` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    image_overlay_play = StringProperty(
+        'atlas://data/images/defaulttheme/player-play-overlay')
+    '''Image filename used to show a "play" overlay when the video has not yet
+    started.
+
+    :attr:`image_overlay_play` is a
+    :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/player-play-overlay'.
+
+    '''
+
+    image_loading = StringProperty('data/images/image-loading.zip')
+    '''Image filename used when the video is loading.
+
+    :attr:`image_loading` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'data/images/image-loading.zip'.
+    '''
+
+    image_play = StringProperty(
+        'atlas://data/images/defaulttheme/media-playback-start')
+    '''Image filename used for the "Play" button.
+
+    :attr:`image_play` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/media-playback-start'.
+    '''
+
+    image_stop = StringProperty(
+        'atlas://data/images/defaulttheme/media-playback-stop')
+    '''Image filename used for the "Stop" button.
+
+    :attr:`image_stop` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/media-playback-stop'.
+    '''
+
+    image_pause = StringProperty(
+        'atlas://data/images/defaulttheme/media-playback-pause')
+    '''Image filename used for the "Pause" button.
+
+    :attr:`image_pause` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/media-playback-pause'.
+    '''
+
+    image_volumehigh = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-high')
+    '''Image filename used for the volume icon when the volume is high.
+
+    :attr:`image_volumehigh` is a :class:`~kivy.properties.StringProperty` and
+    defaults to 'atlas://data/images/defaulttheme/audio-volume-high'.
+    '''
+
+    image_volumemedium = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-medium')
+    '''Image filename used for the volume icon when the volume is medium.
+
+    :attr:`image_volumemedium` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/audio-volume-medium'.
+    '''
+
+    image_volumelow = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-low')
+    '''Image filename used for the volume icon when the volume is low.
+
+    :attr:`image_volumelow` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/audio-volume-low'.
+    '''
+
+    image_volumemuted = StringProperty(
+        'atlas://data/images/defaulttheme/audio-volume-muted')
+    '''Image filename used for the volume icon when the volume is muted.
+
+    :attr:`image_volumemuted` is a :class:`~kivy.properties.StringProperty`
+    and defaults to 'atlas://data/images/defaulttheme/audio-volume-muted'.
+    '''
+
+    annotations = StringProperty('')
+    '''If set, it will be used for reading annotations box.
+
+    :attr:`annotations` is a :class:`~kivy.properties.StringProperty`
+    and defaults to ''.
+    '''
+
+    fullscreen = BooleanProperty(False)
+    '''Switch to fullscreen view. This should be used with care. When
+    activated, the widget will remove itself from its parent, remove all
+    children from the window and will add itself to it. When fullscreen is
+    unset, all the previous children are restored and the widget is restored to
+    its previous parent.
+
+    .. warning::
+
+        The re-add operation doesn't care about the index position of its
+        children within the parent.
+
+    :attr:`fullscreen` is a :class:`~kivy.properties.BooleanProperty`
+    and defaults to False.
+    '''
+
+    allow_fullscreen = BooleanProperty(True)
+    '''By default, you can double-tap on the video to make it fullscreen. Set
+    this property to False to prevent this behavior.
+
+    :attr:`allow_fullscreen` is a :class:`~kivy.properties.BooleanProperty`
+    defaults to True.
+    '''
+
+    options = DictProperty({})
+    '''Optional parameters can be passed to a :class:`~kivy.uix.video.Video`
+    instance with this property.
+
+    :attr:`options` a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+    '''
+
+    # internals
+    container = ObjectProperty(None)
+
+    _video_load_ev = None
+
+    def __init__(self, **kwargs):
+        self._video = None
+        self._image = None
+        self._annotations = ''
+        self._annotations_labels = []
+        super(VideoPlayer, self).__init__(**kwargs)
+        update_thumbnail = self._update_thumbnail
+        update_annotations = self._update_annotations
+        fbind = self.fbind
+        fbind('thumbnail', update_thumbnail)
+        fbind('annotations', update_annotations)
+
+        if self.source:
+            self._trigger_video_load()
+
+    def _trigger_video_load(self, *largs):
+        ev = self._video_load_ev
+        if ev is None:
+            ev = self._video_load_ev = Clock.schedule_once(self._do_video_load,
+                                                           -1)
+        ev()
+
+    def _try_load_default_thumbnail(self, *largs):
+        if not self.thumbnail:
+            filename = self.source.rsplit('.', 1)
+            thumbnail = filename[0] + '.png'
+            if exists(thumbnail):
+                self._load_thumbnail(thumbnail)
+
+    def _try_load_default_annotations(self, *largs):
+        if not self.annotations:
+            filename = self.source.rsplit('.', 1)
+            annotations = filename[0] + '.jsa'
+            if exists(annotations):
+                self._load_annotations(annotations)
+
+    def on_source(self, instance, value):
+        # By default, VideoPlayer should look for thumbnail and annotations
+        # with the same filename (except extension) of the source (video) file.
+        Clock.schedule_once(self._try_load_default_thumbnail, -1)
+        Clock.schedule_once(self._try_load_default_annotations, -1)
+        if self._video is not None:
+            self._video.unload()
+            self._video = None
+        if value:
+            self._trigger_video_load()
+
+    def _update_thumbnail(self, *largs):
+        self._load_thumbnail(self.thumbnail)
+
+    def _update_annotations(self, *largs):
+        self._load_annotations(self.annotations)
+
+    def on_image_overlay_play(self, instance, value):
+        self._image.image_overlay_play = value
+
+    def on_image_loading(self, instance, value):
+        self._image.image_loading = value
+
+    def _load_thumbnail(self, thumbnail):
+        if not self.container:
+            return
+        self.container.clear_widgets()
+        if thumbnail:
+            self._image = VideoPlayerPreview(source=thumbnail, video=self)
+            self.container.add_widget(self._image)
+
+    def _load_annotations(self, annotations):
+        if not self.container:
+            return
+        self._annotations_labels = []
+        if annotations:
+            with open(annotations, 'r') as fd:
+                self._annotations = load(fd)
+            if self._annotations:
+                for ann in self._annotations:
+                    self._annotations_labels.append(
+                        VideoPlayerAnnotation(annotation=ann))
+
+    def on_state(self, instance, value):
+        if self._video is not None:
+            self._video.state = value
+
+    def _set_state(self, instance, value):
+        self.state = value
+
+    def _do_video_load(self, *largs):
+        self._video = Video(source=self.source, state=self.state,
+                            volume=self.volume, pos_hint={'x': 0, 'y': 0},
+                            **self.options)
+        self._video.bind(texture=self._play_started,
+                         duration=self.setter('duration'),
+                         position=self.setter('position'),
+                         volume=self.setter('volume'),
+                         state=self._set_state)
+
+    def on_play(self, instance, value):
+        value = 'play' if value else 'stop'
+        return self.on_state(instance, value)
+
+    def on_volume(self, instance, value):
+        if not self._video:
+            return
+        self._video.volume = value
+
+    def on_position(self, instance, value):
+        labels = self._annotations_labels
+        if not labels:
+            return
+        for label in labels:
+            start = label.start
+            duration = label.duration
+            if start > value or (start + duration) < value:
+                if label.parent:
+                    label.parent.remove_widget(label)
+            elif label.parent is None:
+                self.container.add_widget(label)
+
+    def seek(self, percent, precise=True):
+        '''Change the position to a percentage (strictly, a proportion)
+           of duration.
+
+        :Parameters:
+            `percent`: float or int
+                Position to seek as a proportion of total duration, must
+                be between 0-1.
+            `precise`: bool, defaults to True
+                Precise seeking is slower, but seeks to exact requested
+                percent.
+
+        .. warning::
+            Calling seek() before the video is loaded has no effect.
+
+        .. versionadded:: 1.2.0
+
+        .. versionchanged:: 1.10.1
+            The `precise` keyword argument has been added.
+        '''
+        if not self._video:
+            return
+        self._video.seek(percent, precise=precise)
+
+    def _play_started(self, instance, value):
+        self.container.clear_widgets()
+        self.container.add_widget(self._video)
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(*touch.pos):
+            return False
+        if touch.is_double_tap and self.allow_fullscreen:
+            self.fullscreen = not self.fullscreen
+            return True
+        return super(VideoPlayer, self).on_touch_down(touch)
+
+    def on_fullscreen(self, instance, value):
+        window = self.get_parent_window()
+        if not window:
+            Logger.warning('VideoPlayer: Cannot switch to fullscreen, '
+                           'window not found.')
+            if value:
+                self.fullscreen = False
+            return
+        if not self.parent:
+            Logger.warning('VideoPlayer: Cannot switch to fullscreen, '
+                           'no parent.')
+            if value:
+                self.fullscreen = False
+            return
+
+        if value:
+            self._fullscreen_state = state = {
+                'parent': self.parent,
+                'pos': self.pos,
+                'size': self.size,
+                'pos_hint': self.pos_hint,
+                'size_hint': self.size_hint,
+                'window_children': window.children[:]}
+
+            # remove all window children
+            for child in window.children[:]:
+                window.remove_widget(child)
+
+            # put the video in fullscreen
+            if state['parent'] is not window:
+                state['parent'].remove_widget(self)
+            window.add_widget(self)
+
+            # ensure the video widget is in 0, 0, and the size will be
+            # readjusted
+            self.pos = (0, 0)
+            self.size = (100, 100)
+            self.pos_hint = {}
+            self.size_hint = (1, 1)
+        else:
+            state = self._fullscreen_state
+            window.remove_widget(self)
+            for child in state['window_children']:
+                window.add_widget(child)
+            self.pos_hint = state['pos_hint']
+            self.size_hint = state['size_hint']
+            self.pos = state['pos']
+            self.size = state['size']
+            if state['parent'] is not window:
+                state['parent'].add_widget(self)
+
+
+if __name__ == '__main__':
+    import sys
+    from kivy.base import runTouchApp
+    player = VideoPlayer(source=sys.argv[1])
+    runTouchApp(player)
+    if player:
+        player.state = 'stop'
diff --git a/kivy/uix/vkeyboard.py b/kivy/uix/vkeyboard.py
new file mode 100644
index 0000000..ad7fba2
--- /dev/null
+++ b/kivy/uix/vkeyboard.py
@@ -0,0 +1,879 @@
+'''
+VKeyboard
+=========
+
+.. image:: images/vkeyboard.jpg
+    :align: right
+
+.. versionadded:: 1.0.8
+
+
+VKeyboard is an onscreen keyboard for Kivy. Its operation is intended to be
+transparent to the user. Using the widget directly is NOT recommended. Read the
+section `Request keyboard`_ first.
+
+Modes
+-----
+
+This virtual keyboard has a docked and free mode:
+
+* docked mode (:attr:`VKeyboard.docked` = True)
+  Generally used when only one person is using the computer, like a tablet or
+  personal computer etc.
+* free mode: (:attr:`VKeyboard.docked` = False)
+  Mostly for multitouch surfaces. This mode allows multiple virtual
+  keyboards to be used on the screen.
+
+If the docked mode changes, you need to manually call
+:meth:`VKeyboard.setup_mode` otherwise the change will have no impact.
+During that call, the VKeyboard, implemented on top of a
+:class:`~kivy.uix.scatter.Scatter`, will change the
+behavior of the scatter and position the keyboard near the target (if target
+and docked mode is set).
+
+
+Layouts
+-------
+
+The virtual keyboard is able to load a custom layout. If you create a new
+layout and put the JSON in :file:`<kivy_data_dir>/keyboards/<layoutid>.json`,
+you can load it by setting :attr:`VKeyboard.layout` to your layoutid.
+
+The JSON must be structured like this::
+
+    {
+        "title": "Title of your layout",
+        "description": "Description of your layout",
+        "cols": 15,
+        "rows": 5,
+
+        ...
+    }
+
+Then, you need to describe the keys in each row, for either a "normal",
+"shift" or a "special" (added in version 1.9.0) mode. Keys for this row
+data must be named `normal_<row>`, `shift_<row>` and `special_<row>`.
+Replace `row` with the row number.
+Inside each row, you will describe the key. A key is a 4 element list in
+the format::
+
+    [ <text displayed on the keyboard>, <text to put when the key is pressed>,
+      <text that represents the keycode>, <size of cols> ]
+
+Here are example keys::
+
+    # f key
+    ["f", "f", "f", 1]
+    # capslock
+    ["\u21B9", "\t", "tab", 1.5]
+
+Finally, complete the JSON::
+
+    {
+        ...
+        "normal_1": [
+            ["`", "`", "`", 1],    ["1", "1", "1", 1],    ["2", "2", "2", 1],
+            ["3", "3", "3", 1],    ["4", "4", "4", 1],    ["5", "5", "5", 1],
+            ["6", "6", "6", 1],    ["7", "7", "7", 1],    ["8", "8", "8", 1],
+            ["9", "9", "9", 1],    ["0", "0", "0", 1],    ["+", "+", "+", 1],
+            ["=", "=", "=", 1],    ["\u232b", null, "backspace", 2]
+        ],
+
+        "shift_1": [ ... ],
+        "normal_2": [ ... ],
+        "special_2": [ ... ],
+        ...
+    }
+
+
+Request Keyboard
+----------------
+
+The instantiation of the virtual keyboard is controlled by the configuration.
+Check `keyboard_mode` and `keyboard_layout` in the :doc:`api-kivy.config`.
+
+If you intend to create a widget that requires a keyboard, do not use the
+virtual keyboard directly, but prefer to use the best method available on
+the platform. Check the :meth:`~kivy.core.window.WindowBase.request_keyboard`
+method in the :doc:`api-kivy.core.window`.
+
+If you want a specific layout when you request the keyboard, you should write
+something like this (from 1.8.0, numeric.json can be in the same directory as
+your main.py)::
+
+    keyboard = Window.request_keyboard(
+        self._keyboard_close, self)
+    if keyboard.widget:
+        vkeyboard = self._keyboard.widget
+        vkeyboard.layout = 'numeric.json'
+
+'''
+
+__all__ = ('VKeyboard', )
+
+from kivy import kivy_data_dir
+from kivy.vector import Vector
+from kivy.config import Config
+from kivy.uix.scatter import Scatter
+from kivy.uix.label import Label
+from kivy.properties import ObjectProperty, NumericProperty, StringProperty, \
+    BooleanProperty, DictProperty, OptionProperty, ListProperty, ColorProperty
+from kivy.logger import Logger
+from kivy.graphics import Color, BorderImage, Canvas
+from kivy.core.image import Image
+from kivy.resources import resource_find
+from kivy.clock import Clock
+
+from io import open
+from os.path import join, splitext, basename
+from os import listdir
+from json import loads
+
+
+default_layout_path = join(kivy_data_dir, 'keyboards')
+
+
+class VKeyboard(Scatter):
+    '''
+    VKeyboard is an onscreen keyboard with multitouch support.
+    Its layout is entirely customizable and you can switch between available
+    layouts using a button in the bottom right of the widget.
+
+    :Events:
+        `on_key_down`: keycode, internal, modifiers
+            Fired when the keyboard received a key down event (key press).
+        `on_key_up`: keycode, internal, modifiers
+            Fired when the keyboard received a key up event (key release).
+    '''
+
+    target = ObjectProperty(None, allownone=True)
+    '''Target widget associated with the VKeyboard. If set, it will be used to
+    send keyboard events. If the VKeyboard mode is "free", it will also be used
+    to set the initial position.
+
+    :attr:`target` is an :class:`~kivy.properties.ObjectProperty` instance and
+    defaults to None.
+    '''
+
+    callback = ObjectProperty(None, allownone=True)
+    '''Callback can be set to a function that will be called if the
+    VKeyboard is closed by the user.
+
+    :attr:`target` is an :class:`~kivy.properties.ObjectProperty` instance and
+    defaults to None.
+    '''
+
+    layout = StringProperty(None)
+    '''Layout to use for the VKeyboard. By default, it will be the
+    layout set in the configuration, according to the `keyboard_layout`
+    in `[kivy]` section.
+
+    .. versionchanged:: 1.8.0
+        If layout is a .json filename, it will loaded and added to the
+        available_layouts.
+
+    :attr:`layout` is a :class:`~kivy.properties.StringProperty` and defaults
+    to None.
+    '''
+
+    layout_path = StringProperty(default_layout_path)
+    '''Path from which layouts are read.
+
+    :attr:`layout` is a :class:`~kivy.properties.StringProperty` and
+    defaults to :file:`<kivy_data_dir>/keyboards/`
+    '''
+
+    available_layouts = DictProperty({})
+    '''Dictionary of all available layouts. Keys are the layout ID, and the
+    value is the JSON (translated into a Python object).
+
+    :attr:`available_layouts` is a :class:`~kivy.properties.DictProperty` and
+    defaults to {}.
+    '''
+
+    docked = BooleanProperty(False)
+    '''Indicate whether the VKeyboard is docked on the screen or not. If you
+    change it, you must manually call :meth:`setup_mode` otherwise it will have
+    no impact. If the VKeyboard is created by the Window, the docked mode will
+    be automatically set by the configuration, using the `keyboard_mode` token
+    in `[kivy]` section.
+
+    :attr:`docked` is a :class:`~kivy.properties.BooleanProperty` and defaults
+    to False.
+    '''
+
+    margin_hint = ListProperty([.05, .06, .05, .06])
+    '''Margin hint, used as spacing between keyboard background and keys
+    content. The margin is composed of four values, between 0 and 1::
+
+        margin_hint = [top, right, bottom, left]
+
+    The margin hints will be multiplied by width and height, according to their
+    position.
+
+    :attr:`margin_hint` is a :class:`~kivy.properties.ListProperty` and
+    defaults to [.05, .06, .05, .06]
+    '''
+
+    key_margin = ListProperty([2, 2, 2, 2])
+    '''Key margin, used to create space between keys. The margin is composed of
+    four values, in pixels::
+
+        key_margin = [top, right, bottom, left]
+
+    :attr:`key_margin` is a :class:`~kivy.properties.ListProperty` and defaults
+    to [2, 2, 2, 2]
+    '''
+
+    font_size = NumericProperty(20.)
+    '''font_size, specifies the size of the text on the virtual keyboard keys.
+    It should be kept within limits to ensure the text does not extend beyond
+    the bounds of the key or become too small to read.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`font_size` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 20.
+    '''
+
+    background_color = ColorProperty([1, 1, 1, 1])
+    '''Background color, in the format (r, g, b, a). If a background is
+    set, the color will be combined with the background texture.
+
+    :attr:`background_color` is a :class:`~kivy.properties.ColorProperty` and
+    defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    background = StringProperty(
+        'atlas://data/images/defaulttheme/vkeyboard_background')
+    '''Filename of the background image.
+
+    :attr:`background` is a :class:`~kivy.properties.StringProperty` and
+    defaults to :file:`atlas://data/images/defaulttheme/vkeyboard_background`.
+    '''
+
+    background_disabled = StringProperty(
+        'atlas://data/images/defaulttheme/vkeyboard_disabled_background')
+    '''Filename of the background image when the vkeyboard is disabled.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`background_disabled` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    :file:`atlas://data/images/defaulttheme/vkeyboard__disabled_background`.
+
+    '''
+
+    key_background_color = ColorProperty([1, 1, 1, 1])
+    '''Key background color, in the format (r, g, b, a). If a key background is
+    set, the color will be combined with the key background texture.
+
+    :attr:`key_background_color` is a :class:`~kivy.properties.ColorProperty`
+    and defaults to [1, 1, 1, 1].
+
+    .. versionchanged:: 2.0.0
+        Changed from :class:`~kivy.properties.ListProperty` to
+        :class:`~kivy.properties.ColorProperty`.
+    '''
+
+    key_background_normal = StringProperty(
+        'atlas://data/images/defaulttheme/vkeyboard_key_normal')
+    '''Filename of the key background image for use when no touches are active
+    on the widget.
+
+    :attr:`key_background_normal` is a :class:`~kivy.properties.StringProperty`
+    and defaults to
+    :file:`atlas://data/images/defaulttheme/vkeyboard_key_normal`.
+    '''
+
+    key_disabled_background_normal = StringProperty(
+        'atlas://data/images/defaulttheme/vkeyboard_key_normal')
+    '''Filename of the key background image for use when no touches are active
+    on the widget and vkeyboard is disabled.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`key_disabled_background_normal` is a
+    :class:`~kivy.properties.StringProperty` and defaults to
+    :file:`atlas://data/images/defaulttheme/vkeyboard_disabled_key_normal`.
+
+    '''
+
+    key_background_down = StringProperty(
+        'atlas://data/images/defaulttheme/vkeyboard_key_down')
+    '''Filename of the key background image for use when a touch is active
+    on the widget.
+
+    :attr:`key_background_down` is a :class:`~kivy.properties.StringProperty`
+    and defaults to
+    :file:`atlas://data/images/defaulttheme/vkeyboard_key_down`.
+    '''
+
+    background_border = ListProperty([16, 16, 16, 16])
+    '''Background image border. Used for controlling the
+    :attr:`~kivy.graphics.vertex_instructions.BorderImage.border` property of
+    the background.
+
+    :attr:`background_border` is a :class:`~kivy.properties.ListProperty` and
+    defaults to [16, 16, 16, 16]
+    '''
+
+    key_border = ListProperty([8, 8, 8, 8])
+    '''Key image border. Used for controlling the
+    :attr:`~kivy.graphics.vertex_instructions.BorderImage.border` property of
+    the key.
+
+    :attr:`key_border` is a :class:`~kivy.properties.ListProperty` and
+    defaults to [16, 16, 16, 16]
+    '''
+
+    # XXX internal variables
+    layout_mode = OptionProperty('normal',
+        options=('normal', 'shift', 'special'))
+    layout_geometry = DictProperty({})
+    have_capslock = BooleanProperty(False)
+    have_shift = BooleanProperty(False)
+    have_special = BooleanProperty(False)
+    active_keys = DictProperty({})
+    font_name = StringProperty('data/fonts/DejaVuSans.ttf')
+    repeat_touch = ObjectProperty(allownone=True)
+
+    _start_repeat_key_ev = None
+    _repeat_key_ev = None
+
+    __events__ = ('on_key_down', 'on_key_up', 'on_textinput')
+
+    def __init__(self, **kwargs):
+        # XXX move to style.kv
+        if 'size_hint' not in kwargs:
+            if 'size_hint_x' not in kwargs:
+                self.size_hint_x = None
+            if 'size_hint_y' not in kwargs:
+                self.size_hint_y = None
+        if 'size' not in kwargs:
+            if 'width' not in kwargs:
+                self.width = 700
+            if 'height' not in kwargs:
+                self.height = 200
+        if 'scale_min' not in kwargs:
+            self.scale_min = .4
+        if 'scale_max' not in kwargs:
+            self.scale_max = 1.6
+        if 'docked' not in kwargs:
+            self.docked = False
+
+        layout_mode = self._trigger_update_layout_mode = Clock.create_trigger(
+            self._update_layout_mode)
+        layouts = self._trigger_load_layouts = Clock.create_trigger(
+            self._load_layouts)
+        layout = self._trigger_load_layout = Clock.create_trigger(
+            self._load_layout)
+        fbind = self.fbind
+
+        fbind('docked', self.setup_mode)
+        fbind('have_shift', layout_mode)
+        fbind('have_capslock', layout_mode)
+        fbind('have_special', layout_mode)
+        fbind('layout_path', layouts)
+        fbind('layout', layout)
+        super(VKeyboard, self).__init__(**kwargs)
+
+        # load all the layouts found in the layout_path directory
+        self._load_layouts()
+
+        # ensure we have default layouts
+        available_layouts = self.available_layouts
+        if not available_layouts:
+            Logger.critical('VKeyboard: unable to load default layouts')
+
+        # load the default layout from configuration
+        if self.layout is None:
+            self.layout = Config.get('kivy', 'keyboard_layout')
+        else:
+            # ensure the current layout is found on the available layout
+            self._trigger_load_layout()
+
+        # update layout mode (shift or normal)
+        self._trigger_update_layout_mode()
+
+        # create a top layer to draw active keys on
+        with self.canvas:
+            self.background_key_layer = Canvas()
+            self.active_keys_layer = Canvas()
+
+    def on_disabled(self, instance, value):
+        self.refresh_keys()
+
+    def _update_layout_mode(self, *l):
+        # update mode according to capslock and shift key
+        mode = self.have_capslock != self.have_shift
+        mode = 'shift' if mode else 'normal'
+        if self.have_special:
+            mode = "special"
+        if mode != self.layout_mode:
+            self.layout_mode = mode
+            self.refresh(False)
+
+    def _load_layout(self, *largs):
+        # ensure new layouts are loaded first
+        if self._trigger_load_layouts.is_triggered:
+            self._load_layouts()
+            self._trigger_load_layouts.cancel()
+
+        value = self.layout
+        available_layouts = self.available_layouts
+
+        # it's a filename, try to load it directly
+        if self.layout[-5:] == '.json':
+            if value not in available_layouts:
+                fn = resource_find(self.layout)
+                self._load_layout_fn(fn, self.layout)
+
+        if not available_layouts:
+            return
+        if value not in available_layouts and value != 'qwerty':
+            Logger.error(
+                'Vkeyboard: <%s> keyboard layout mentioned in '
+                'conf file was not found, fallback on qwerty' %
+                value)
+            self.layout = 'qwerty'
+        self.refresh(True)
+
+    def _load_layouts(self, *largs):
+        # first load available layouts from json files
+        # XXX fix to be able to reload layout when path is changing
+        value = self.layout_path
+        for fn in listdir(value):
+            self._load_layout_fn(join(value, fn),
+                                 basename(splitext(fn)[0]))
+
+    def _load_layout_fn(self, fn, name):
+        available_layouts = self.available_layouts
+        if fn[-5:] != '.json':
+            return
+        with open(fn, 'r', encoding='utf-8') as fd:
+            json_content = fd.read()
+            layout = loads(json_content)
+        available_layouts[name] = layout
+
+    def setup_mode(self, *largs):
+        '''Call this method when you want to readjust the keyboard according to
+        options: :attr:`docked` or not, with attached :attr:`target` or not:
+
+        * If :attr:`docked` is True, it will call :meth:`setup_mode_dock`
+        * If :attr:`docked` is False, it will call :meth:`setup_mode_free`
+
+        Feel free to overload these methods to create new
+        positioning behavior.
+        '''
+        if self.docked:
+            self.setup_mode_dock()
+        else:
+            self.setup_mode_free()
+
+    def setup_mode_dock(self, *largs):
+        '''Setup the keyboard in docked mode.
+
+        Dock mode will reset the rotation, disable translation, rotation and
+        scale. Scale and position will be automatically adjusted to attach the
+        keyboard to the bottom of the screen.
+
+        .. note::
+            Don't call this method directly, use :meth:`setup_mode` instead.
+        '''
+        self.do_translation = False
+        self.do_rotation = False
+        self.do_scale = False
+        self.rotation = 0
+        win = self.get_parent_window()
+        scale = win.width / float(self.width)
+        self.scale = scale
+        self.pos = 0, 0
+        win.bind(on_resize=self._update_dock_mode)
+
+    def _update_dock_mode(self, win, *largs):
+        scale = win.width / float(self.width)
+        self.scale = scale
+        self.pos = 0, 0
+
+    def setup_mode_free(self):
+        '''Setup the keyboard in free mode.
+
+        Free mode is designed to let the user control the position and
+        orientation of the keyboard. The only real usage is for a multiuser
+        environment, but you might found other ways to use it.
+        If a :attr:`target` is set, it will place the vkeyboard under the
+        target.
+
+        .. note::
+            Don't call this method directly, use :meth:`setup_mode` instead.
+        '''
+        self.do_translation = True
+        self.do_rotation = True
+        self.do_scale = True
+        target = self.target
+        if not target:
+            return
+
+        # NOTE all math will be done in window point of view
+        # determine rotation of the target
+        a = Vector(1, 0)
+        b = Vector(target.to_window(0, 0))
+        c = Vector(target.to_window(1, 0)) - b
+        self.rotation = -a.angle(c)
+
+        # determine the position of center/top of the keyboard
+        dpos = Vector(self.to_window(self.width / 2., self.height))
+
+        # determine the position of center/bottom of the target
+        cpos = Vector(target.to_window(target.center_x, target.y))
+
+        # the goal now is to map both point, calculate the diff between them
+        diff = dpos - cpos
+
+        # we still have an issue, self.pos represent the bounding box,
+        # not the 0,0 coordinate of the scatter. we need to apply also
+        # the diff between them (inside and outside coordinate matrix).
+        # It's hard to explain, but do a scheme on a paper, write all
+        # the vector i'm calculating, and you'll understand. :)
+        diff2 = Vector(self.x + self.width / 2., self.y + self.height) - \
+            Vector(self.to_parent(self.width / 2., self.height))
+        diff -= diff2
+
+        # now we have a good "diff", set it as a pos.
+        self.pos = -diff
+
+    def change_layout(self):
+        # XXX implement popup with all available layouts
+        pass
+
+    def refresh(self, force=False):
+        '''(internal) Recreate the entire widget and graphics according to the
+        selected layout.
+        '''
+        self.clear_widgets()
+        if force:
+            self.refresh_keys_hint()
+        self.refresh_keys()
+        self.refresh_active_keys_layer()
+
+    def refresh_active_keys_layer(self):
+        self.active_keys_layer.clear()
+
+        active_keys = self.active_keys
+        layout_geometry = self.layout_geometry
+        background = resource_find(self.key_background_down)
+        texture = Image(background, mipmap=True).texture
+
+        with self.active_keys_layer:
+            Color(*self.key_background_color)
+            for line_nb, index in active_keys.values():
+                pos, size = layout_geometry['LINE_%d' % line_nb][index]
+                BorderImage(texture=texture, pos=pos, size=size,
+                            border=self.key_border)
+
+    def refresh_keys_hint(self):
+        layout = self.available_layouts[self.layout]
+        layout_cols = layout['cols']
+        layout_rows = layout['rows']
+        layout_geometry = self.layout_geometry
+        mtop, mright, mbottom, mleft = self.margin_hint
+
+        # get relative EFFICIENT surface of the layout without external margins
+        el_hint = 1. - mleft - mright
+        eh_hint = 1. - mtop - mbottom
+        ex_hint = 0 + mleft
+        ey_hint = 0 + mbottom
+
+        # get relative unit surface
+        uw_hint = (1. / layout_cols) * el_hint
+        uh_hint = (1. / layout_rows) * eh_hint
+        layout_geometry['U_HINT'] = (uw_hint, uh_hint)
+
+        # calculate individual key RELATIVE surface and pos (without key
+        # margin)
+        current_y_hint = ey_hint + eh_hint
+        for line_nb in range(1, layout_rows + 1):
+            current_y_hint -= uh_hint
+            # get line_name
+            line_name = '%s_%d' % (self.layout_mode, line_nb)
+            line_hint = 'LINE_HINT_%d' % line_nb
+            layout_geometry[line_hint] = []
+            current_x_hint = ex_hint
+            # go through the list of keys (tuples of 4)
+            for key in layout[line_name]:
+                # calculate relative pos, size
+                layout_geometry[line_hint].append([
+                    (current_x_hint, current_y_hint),
+                    (key[3] * uw_hint, uh_hint)])
+                current_x_hint += key[3] * uw_hint
+
+        self.layout_geometry = layout_geometry
+
+    def refresh_keys(self):
+        layout = self.available_layouts[self.layout]
+        layout_rows = layout['rows']
+        layout_geometry = self.layout_geometry
+        w, h = self.size
+        kmtop, kmright, kmbottom, kmleft = self.key_margin
+        uw_hint, uh_hint = layout_geometry['U_HINT']
+
+        for line_nb in range(1, layout_rows + 1):
+            llg = layout_geometry['LINE_%d' % line_nb] = []
+            llg_append = llg.append
+            for key in layout_geometry['LINE_HINT_%d' % line_nb]:
+                x_hint, y_hint = key[0]
+                w_hint, h_hint = key[1]
+                kx = x_hint * w
+                ky = y_hint * h
+                kw = w_hint * w
+                kh = h_hint * h
+
+                # now adjust, considering the key margin
+                kx = int(kx + kmleft)
+                ky = int(ky + kmbottom)
+                kw = int(kw - kmleft - kmright)
+                kh = int(kh - kmbottom - kmtop)
+
+                pos = (kx, ky)
+                size = (kw, kh)
+                llg_append((pos, size))
+
+        self.layout_geometry = layout_geometry
+        self.draw_keys()
+
+    def draw_keys(self):
+        layout = self.available_layouts[self.layout]
+        layout_rows = layout['rows']
+        layout_geometry = self.layout_geometry
+        layout_mode = self.layout_mode
+
+        # draw background
+        background = resource_find(self.background_disabled
+                                   if self.disabled else
+                                   self.background)
+        texture = Image(background, mipmap=True).texture
+        self.background_key_layer.clear()
+        with self.background_key_layer:
+            Color(*self.background_color)
+            BorderImage(texture=texture, size=self.size,
+                        border=self.background_border)
+
+        # XXX separate drawing the keys and the fonts to avoid
+        # XXX reloading the texture each time
+
+        # first draw keys without the font
+        key_normal = resource_find(self.key_background_disabled_normal
+                                   if self.disabled else
+                                   self.key_background_normal)
+        texture = Image(key_normal, mipmap=True).texture
+        with self.background_key_layer:
+            Color(*self.key_background_color)
+            for line_nb in range(1, layout_rows + 1):
+                for pos, size in layout_geometry['LINE_%d' % line_nb]:
+                    BorderImage(texture=texture, pos=pos, size=size,
+                                border=self.key_border)
+
+        # then draw the text
+        for line_nb in range(1, layout_rows + 1):
+            key_nb = 0
+            for pos, size in layout_geometry['LINE_%d' % line_nb]:
+                # retrieve the relative text
+                text = layout[layout_mode + '_' + str(line_nb)][key_nb][0]
+                z = Label(text=text, font_size=self.font_size, pos=pos,
+                           size=size, font_name=self.font_name)
+                self.add_widget(z)
+                key_nb += 1
+
+    def on_key_down(self, *largs):
+        pass
+
+    def on_key_up(self, *largs):
+        pass
+
+    def on_textinput(self, *largs):
+        pass
+
+    def get_key_at_pos(self, x, y):
+        w, h = self.size
+        x_hint = x / w
+        # focus on the surface without margins
+        layout_geometry = self.layout_geometry
+        layout = self.available_layouts[self.layout]
+        layout_rows = layout['rows']
+        mtop, mright, mbottom, mleft = self.margin_hint
+
+        # get the line of the layout
+        e_height = h - (mbottom + mtop) * h  # efficient height in pixels
+        line_height = e_height / layout_rows  # line height in px
+        y = y - mbottom * h
+        line_nb = layout_rows - int(y / line_height)
+
+        if line_nb > layout_rows:
+            line_nb = layout_rows
+        if line_nb < 1:
+            line_nb = 1
+
+        # get the key within the line
+        key_index = ''
+        current_key_index = 0
+        for key in layout_geometry['LINE_HINT_%d' % line_nb]:
+            if x_hint >= key[0][0] and x_hint < key[0][0] + key[1][0]:
+                key_index = current_key_index
+                break
+            else:
+                current_key_index += 1
+        if key_index == '':
+            return None
+
+        # get the full character
+        key = layout['%s_%d' % (self.layout_mode, line_nb)][key_index]
+
+        return [key, (line_nb, key_index)]
+
+    def collide_margin(self, x, y):
+        '''Do a collision test, and return True if the (x, y) is inside the
+        vkeyboard margin.
+        '''
+        mtop, mright, mbottom, mleft = self.margin_hint
+        x_hint = x / self.width
+        y_hint = y / self.height
+        if x_hint > mleft and x_hint < 1. - mright \
+                and y_hint > mbottom and y_hint < 1. - mtop:
+            return False
+        return True
+
+    def process_key_on(self, touch):
+        if not touch:
+            return
+        x, y = self.to_local(*touch.pos)
+        key = self.get_key_at_pos(x, y)
+        if not key:
+            return
+
+        key_data = key[0]
+        displayed_char, internal, special_char, size = key_data
+        line_nb, key_index = key[1]
+
+        # save pressed key on the touch
+        ud = touch.ud[self.uid] = {}
+        ud['key'] = key
+
+        # for caps lock or shift only:
+        uid = touch.uid
+        if special_char is not None:
+            # Do not repeat special keys
+            if special_char in ('capslock', 'shift', 'layout', 'special'):
+                if self._start_repeat_key_ev is not None:
+                    self._start_repeat_key_ev.cancel()
+                    self._start_repeat_key_ev = None
+                self.repeat_touch = None
+            if special_char == 'capslock':
+                self.have_capslock = not self.have_capslock
+                uid = -1
+            elif special_char == 'shift':
+                self.have_shift = True
+            elif special_char == 'special':
+                self.have_special = True
+            elif special_char == 'layout':
+                self.change_layout()
+
+        # send info to the bus
+        b_keycode = special_char
+        b_modifiers = self._get_modifiers()
+        if self.get_parent_window().__class__.__module__ == \
+            'kivy.core.window.window_sdl2' and internal:
+            self.dispatch('on_textinput', internal)
+        else:
+            self.dispatch('on_key_down', b_keycode, internal, b_modifiers)
+
+        # save key as an active key for drawing
+        self.active_keys[uid] = key[1]
+        self.refresh_active_keys_layer()
+
+    def process_key_up(self, touch):
+        uid = touch.uid
+        if self.uid not in touch.ud:
+            return
+
+        # save pressed key on the touch
+        key_data, key = touch.ud[self.uid]['key']
+        displayed_char, internal, special_char, size = key_data
+
+        # send info to the bus
+        b_keycode = special_char
+        b_modifiers = self._get_modifiers()
+        self.dispatch('on_key_up', b_keycode, internal, b_modifiers)
+
+        if special_char == 'capslock':
+            uid = -1
+
+        if uid in self.active_keys:
+            self.active_keys.pop(uid, None)
+            if special_char == 'shift':
+                self.have_shift = False
+            elif special_char == 'special':
+                self.have_special = False
+            if special_char == 'capslock' and self.have_capslock:
+                self.active_keys[-1] = key
+            self.refresh_active_keys_layer()
+
+    def _get_modifiers(self):
+        ret = []
+        if self.have_shift:
+            ret.append('shift')
+        if self.have_capslock:
+            ret.append('capslock')
+        return ret
+
+    def _start_repeat_key(self, *kwargs):
+        self._repeat_key_ev = Clock.schedule_interval(self._repeat_key, 0.05)
+
+    def _repeat_key(self, *kwargs):
+        self.process_key_on(self.repeat_touch)
+
+    def on_touch_down(self, touch):
+        x, y = touch.pos
+        if not self.collide_point(x, y):
+            return
+        if self.disabled:
+            return True
+
+        x, y = self.to_local(x, y)
+        if not self.collide_margin(x, y):
+            if self.repeat_touch is None:
+                self._start_repeat_key_ev = Clock.schedule_once(
+                    self._start_repeat_key, 0.5)
+            self.repeat_touch = touch
+
+            self.process_key_on(touch)
+            touch.grab(self, exclusive=True)
+
+        else:
+            super(VKeyboard, self).on_touch_down(touch)
+        return True
+
+    def on_touch_up(self, touch):
+        if touch.grab_current is self:
+            self.process_key_up(touch)
+
+            if self._start_repeat_key_ev is not None:
+                self._start_repeat_key_ev.cancel()
+                self._start_repeat_key_ev = None
+            if touch == self.repeat_touch:
+                if self._repeat_key_ev is not None:
+                    self._repeat_key_ev.cancel()
+                    self._repeat_key_ev = None
+                self.repeat_touch = None
+
+        return super(VKeyboard, self).on_touch_up(touch)
+
+
+if __name__ == '__main__':
+    from kivy.base import runTouchApp
+    vk = VKeyboard(layout='azerty')
+    runTouchApp(vk)
diff --git a/kivy/uix/widget.py b/kivy/uix/widget.py
new file mode 100644
index 0000000..e00b39e
--- /dev/null
+++ b/kivy/uix/widget.py
@@ -0,0 +1,1629 @@
+'''
+Widget class
+============
+
+The :class:`Widget` class is the base class required for creating Widgets.
+This widget class was designed with a couple of principles in mind:
+
+* *Event Driven*
+
+  Widget interaction is built on top of events that occur. If a property
+  changes, the widget can respond to the change in the 'on_<propname>'
+  callback. If nothing changes, nothing will be done. That's the main
+  goal of the :class:`~kivy.properties.Property` class.
+
+* *Separation Of Concerns (the widget and its graphical representation)*
+
+  Widgets don't have a `draw()` method. This is done on purpose: The idea
+  is to allow you to create your own graphical representation outside the
+  widget class.
+  Obviously you can still use all the available properties to do that, so
+  that your representation properly reflects the widget's current state.
+  Every widget has its own :class:`~kivy.graphics.Canvas` that you
+  can use to draw. This separation allows Kivy to run your
+  application in a very efficient manner.
+
+* *Bounding Box / Collision*
+
+  Often you want to know if a certain point is within the bounds of your
+  widget. An example would be a button widget where you only want to
+  trigger an action when the button itself is actually touched.
+  For this, you can use the :meth:`~Widget.collide_point` method, which
+  will return True if the point you pass to it is inside the axis-aligned
+  bounding box defined by the widget's position and size.
+  If a simple AABB is not sufficient, you can override the method to
+  perform the collision checks with more complex shapes, e.g. a polygon.
+  You can also check if a widget collides with another widget with
+  :meth:`~Widget.collide_widget`.
+
+
+We also have some default values and behaviors that you should be aware of:
+
+* A :class:`Widget` is not a :class:`~kivy.uix.layout.Layout`: it will not
+  change the position or the size of its children. If you want control over
+  positioning or sizing, use a :class:`~kivy.uix.layout.Layout`.
+
+* The default size of a widget is (100, 100). This is only changed if the
+  parent is a :class:`~kivy.uix.layout.Layout`.
+  For example, if you add a :class:`Label` inside a
+  :class:`Button`, the label will not inherit the button's size or position
+  because the button is not a *Layout*: it's just another *Widget*.
+
+* The default size_hint is (1, 1). If the parent is a :class:`Layout`, then the
+  widget size will be the parent layout's size.
+
+* :meth:`~Widget.on_touch_down`, :meth:`~Widget.on_touch_move`,
+  :meth:`~Widget.on_touch_up` don't do any sort of collisions. If you want to
+  know if the touch is inside your widget, use :meth:`~Widget.collide_point`.
+
+Using Properties
+----------------
+
+When you read the documentation, all properties are described in the format::
+
+    <name> is a <property class> and defaults to <default value>.
+
+e.g.
+
+    :attr:`~kivy.uix.label.Label.text` is a
+    :class:`~kivy.properties.StringProperty` and defaults to ''.
+
+If you want to be notified when the pos attribute changes, i.e. when the
+widget moves, you can bind your own callback function like this::
+
+    def callback_pos(instance, value):
+        print('The widget', instance, 'moved to', value)
+
+    wid = Widget()
+    wid.bind(pos=callback_pos)
+
+Read more about :doc:`/api-kivy.properties`.
+
+Basic drawing
+-------------
+
+Widgets support a range of drawing instructions that you can use to customize
+the look of your widgets and layouts. For example, to draw a background image
+for your widget, you can do the following:
+
+.. code-block:: python
+
+    def redraw(self, args):
+        self.bg_rect.size = self.size
+        self.bg_rect.pos = self.pos
+
+    widget = Widget()
+    with widget.canvas:
+        widget.bg_rect = Rectangle(source="cover.jpg", pos=self.pos, \
+size=self.size)
+    widget.bind(pos=redraw, size=redraw)
+
+To draw a background in kv:
+
+.. code-block:: kv
+
+    Widget:
+        canvas:
+            Rectangle:
+                source: "cover.jpg"
+                size: self.size
+                pos: self.pos
+
+These examples only scratch the surface. Please see the :mod:`kivy.graphics`
+documentation for more information.
+
+.. _widget-event-bubbling:
+
+Widget touch event bubbling
+---------------------------
+
+When you catch touch events between multiple widgets, you often
+need to be aware of the order in which these events are propagated. In Kivy,
+events bubble up from the first child upwards through the other children.
+If a widget has children, the event is passed through its children before
+being passed on to the widget after it.
+
+As the :meth:`~kivy.uix.widget.Widget.on_touch_up` method inserts widgets at
+index 0 by default, this means the event goes from the most recently added
+widget back to the first one added. Consider the following:
+
+.. code-block:: python
+
+    box = BoxLayout()
+    box.add_widget(Label(text="a"))
+    box.add_widget(Label(text="b"))
+    box.add_widget(Label(text="c"))
+
+The label with text "c" gets the event first, "b" second and "a" last. You can
+reverse this order by manually specifying the index:
+
+.. code-block:: python
+
+    box = BoxLayout()
+    box.add_widget(Label(text="a"), index=0)
+    box.add_widget(Label(text="b"), index=1)
+    box.add_widget(Label(text="c"), index=2)
+
+Now the order would be "a", "b" then "c". One thing to keep in mind when using
+kv is that declaring a widget uses the
+:meth:`~kivy.uix.widget.Widget.add_widget` method for insertion. Hence, using
+
+.. code-block:: kv
+
+    BoxLayout:
+        MyLabel:
+            text: "a"
+        MyLabel:
+            text: "b"
+        MyLabel:
+            text: "c"
+
+would result in the event order "c", "b" then "a" as "c" was actually the last
+added widget. It thus has index 0, "b" index 1 and "a" index 2. Effectively,
+the child order is the reverse of its listed order.
+
+This ordering is the same for the :meth:`~kivy.uix.widget.Widget.on_touch_move`
+and :meth:`~kivy.uix.widget.Widget.on_touch_up` events.
+
+In order to stop this event bubbling, a method can return `True`. This tells
+Kivy the event has been handled and the event propagation stops. For example:
+
+.. code-block:: python
+
+    class MyWidget(Widget):
+        def on_touch_down(self, touch):
+            If <some_condition>:
+                # Do stuff here and kill the event
+                return True
+            else:
+                return super(MyWidget, self).on_touch_down(touch)
+
+This approach gives you good control over exactly how events are dispatched
+and managed. Sometimes, however, you may wish to let the event be completely
+propagated before taking action. You can use the
+:class:`~kivy.clock.Clock` to help you here:
+
+.. code-block:: python
+
+    class MyWidget(Label):
+        def on_touch_down(self, touch, after=False):
+            if after:
+                print "Fired after the event has been dispatched!"
+            else:
+                Clock.schedule_once(lambda dt: self.on_touch_down(touch, True))
+                return super(MyWidget, self).on_touch_down(touch)
+
+Usage of :attr:`Widget.center`, :attr:`Widget.right`, and :attr:`Widget.top`
+----------------------------------------------------------------------------
+
+A common mistake when using one of the computed properties such as
+:attr:`Widget.right` is to use it to make a widget follow its parent with a
+KV rule such as `right: self.parent.right`. Consider, for example:
+
+.. code-block:: kv
+
+    FloatLayout:
+        id: layout
+        width: 100
+        Widget:
+            id: wid
+            right: layout.right
+
+The (mistaken) expectation is that this rule ensures that wid's right will
+always be whatever layout's right is - that is wid.right and layout.right will
+always be identical. In actual fact, this rule only says that "whenever
+layout's `right` changes, wid's right will be set to that value". The
+difference being that as long as `layout.right` doesn't change, `wid.right`
+could be anything, even a value that will make them different.
+
+Specifically, for the KV code above, consider the following example::
+
+    >>> print(layout.right, wid.right)
+    (100, 100)
+    >>> wid.x = 200
+    >>> print(layout.right, wid.right)
+    (100, 300)
+
+As can be seen, initially they are in sync, however, when we change `wid.x`
+they go out of sync because `layout.right` is not changed and the rule is not
+triggered.
+
+The proper way to make the widget follow its parent's right is to use
+:attr:`Widget.pos_hint`. If instead of `right: layout.right` we did
+`pos_hint: {'right': 1}`, then the widgets right will always be set to be
+at the parent's right at each layout update.
+'''
+
+__all__ = ('Widget', 'WidgetException')
+
+from kivy.event import EventDispatcher
+from kivy.eventmanager import (
+    MODE_DONT_DISPATCH,
+    MODE_FILTERED_DISPATCH,
+    MODE_DEFAULT_DISPATCH
+)
+from kivy.factory import Factory
+from kivy.properties import (
+    NumericProperty, StringProperty, AliasProperty, ReferenceListProperty,
+    ObjectProperty, ListProperty, DictProperty, BooleanProperty)
+from kivy.graphics import (
+    Canvas, Translate, Fbo, ClearColor, ClearBuffers, Scale)
+from kivy.graphics.transformation import Matrix
+from kivy.base import EventLoop
+from kivy.lang import Builder
+from kivy.context import get_current_context
+from kivy.weakproxy import WeakProxy
+from functools import partial
+from itertools import islice
+
+
+# References to all the widget destructors (partial method with widget uid as
+# key).
+_widget_destructors = {}
+
+
+def _widget_destructor(uid, r):
+    # Internal method called when a widget is deleted from memory. the only
+    # thing we remember about it is its uid. Clear all the associated callbacks
+    # created in kv language.
+    del _widget_destructors[uid]
+    Builder.unbind_widget(uid)
+
+
+class WidgetException(Exception):
+    '''Fired when the widget gets an exception.
+    '''
+    pass
+
+
+class WidgetMetaclass(type):
+    '''Metaclass to automatically register new widgets for the
+    :class:`~kivy.factory.Factory`.
+
+    .. warning::
+        This metaclass is used by the Widget. Do not use it directly!
+    '''
+    def __init__(mcs, name, bases, attrs):
+        super(WidgetMetaclass, mcs).__init__(name, bases, attrs)
+        Factory.register(name, cls=mcs)
+
+
+#: Base class used for Widget, that inherits from :class:`EventDispatcher`
+WidgetBase = WidgetMetaclass('WidgetBase', (EventDispatcher, ), {})
+
+
+class Widget(WidgetBase):
+    '''Widget class. See module documentation for more information.
+
+    :Events:
+        `on_touch_down`: `(touch, )`
+            Fired when a new touch event occurs. `touch` is the touch object.
+        `on_touch_move`: `(touch, )`
+            Fired when an existing touch moves. `touch` is the touch object.
+        `on_touch_up`: `(touch, )`
+            Fired when an existing touch disappears. `touch` is the touch
+            object.
+        `on_kv_post`: `(base_widget, )`
+            Fired after all the kv rules associated with the widget
+            and all other widgets that are in any of those rules have had
+            all their kv rules applied. `base_widget` is the base-most widget
+            whose instantiation triggered the kv rules (i.e. the widget
+            instantiated from Python, e.g. ``MyWidget()``).
+
+            .. versionchanged:: 1.11.0
+
+    .. warning::
+        Adding a `__del__` method to a class derived from Widget with Python
+        prior to 3.4 will disable automatic garbage collection for instances
+        of that class. This is because the Widget class creates reference
+        cycles, thereby `preventing garbage collection
+        <https://docs.python.org/2/library/gc.html#gc.garbage>`_.
+
+    .. versionchanged:: 1.0.9
+        Everything related to event properties has been moved to the
+        :class:`~kivy.event.EventDispatcher`. Event properties can now be used
+        when constructing a simple class without subclassing :class:`Widget`.
+
+    .. versionchanged:: 1.5.0
+        The constructor now accepts on_* arguments to automatically bind
+        callbacks to properties or events, as in the Kv language.
+    '''
+
+    __metaclass__ = WidgetMetaclass
+    __events__ = (
+        'on_motion', 'on_touch_down', 'on_touch_move', 'on_touch_up',
+        'on_kv_post'
+    )
+    _proxy_ref = None
+
+    def __init__(self, **kwargs):
+        # Before doing anything, ensure the windows exist.
+        EventLoop.ensure_window()
+
+        # Assign the default context of the widget creation.
+        if not hasattr(self, '_context'):
+            self._context = get_current_context()
+
+        no_builder = '__no_builder' in kwargs
+        self._disabled_value = False
+        if no_builder:
+            del kwargs['__no_builder']
+        on_args = {k: v for k, v in kwargs.items() if k[:3] == 'on_'}
+        for key in on_args:
+            del kwargs[key]
+
+        self._disabled_count = 0
+
+        super(Widget, self).__init__(**kwargs)
+
+        # Create the default canvas if it does not exist.
+        if self.canvas is None:
+            self.canvas = Canvas(opacity=self.opacity)
+
+        # Apply all the styles.
+        if not no_builder:
+            rule_children = []
+            self.apply_class_lang_rules(
+                ignored_consts=self._kwargs_applied_init,
+                rule_children=rule_children)
+
+            for widget in rule_children:
+                widget.dispatch('on_kv_post', self)
+            self.dispatch('on_kv_post', self)
+
+        # Bind all the events.
+        if on_args:
+            self.bind(**on_args)
+
+    @property
+    def proxy_ref(self):
+        '''Return a proxy reference to the widget, i.e. without creating a
+        reference to the widget. See `weakref.proxy
+        <http://docs.python.org/2/library/weakref.html?highlight\
+        =proxy#weakref.proxy>`_ for more information.
+
+        .. versionadded:: 1.7.2
+        '''
+        _proxy_ref = self._proxy_ref
+        if _proxy_ref is not None:
+            return _proxy_ref
+
+        f = partial(_widget_destructor, self.uid)
+        self._proxy_ref = _proxy_ref = WeakProxy(self, f)
+        # Only f should be enough here, but it appears that is a very
+        # specific case, the proxy destructor is not called if both f and
+        # _proxy_ref are not together in a tuple.
+        _widget_destructors[self.uid] = (f, _proxy_ref)
+        return _proxy_ref
+
+    def __hash__(self):
+        return id(self)
+
+    def apply_class_lang_rules(
+            self, root=None, ignored_consts=set(), rule_children=None):
+        '''
+        Method that is called by kivy to apply the kv rules of this widget's
+        class.
+
+        :Parameters:
+            `root`: :class:`Widget`
+                The root widget that instantiated this widget in kv, if the
+                widget was instantiated in kv, otherwise ``None``.
+            `ignored_consts`: set
+                (internal) See :meth:`~kivy.lang.builder.BuilderBase.apply`.
+            `rule_children`: list
+                (internal) See :meth:`~kivy.lang.builder.BuilderBase.apply`.
+
+        This is useful to be able to execute code before/after the class kv
+        rules are applied to the widget. E.g. if the kv code requires some
+        properties to be initialized before it is used in a binding rule.
+        If overwriting remember to call ``super``, otherwise the kv rules will
+        not be applied.
+
+        In the following example,
+
+        .. code-block:: python
+
+            class MyWidget(Widget):
+                pass
+
+            class OtherWidget(MyWidget):
+                pass
+
+        .. code-block:: kv
+
+        <MyWidget>:
+            my_prop: some_value
+
+        <OtherWidget>:
+            other_prop: some_value
+
+        When ``OtherWidget`` is instantiated with ``OtherWidget()``, the
+        widget's :meth:`apply_class_lang_rules` is called and it applies the
+        kv rules of this class - ``<MyWidget>`` and ``<OtherWidget>``.
+
+        Similarly, when the widget is instantiated from kv, e.g.
+
+        .. code-block:: kv
+
+            <MyBox@BoxLayout>:
+                height: 55
+                OtherWidget:
+                    width: 124
+
+        ``OtherWidget``'s :meth:`apply_class_lang_rules` is called and it
+        applies the kv rules of this class - ``<MyWidget>`` and
+        ``<OtherWidget>``.
+
+        .. note::
+
+            It applies only the class rules not the instance rules. I.e. in the
+            above kv example in the ``MyBox`` rule when ``OtherWidget`` is
+            instantiated, its :meth:`apply_class_lang_rules` applies the
+            ``<MyWidget>`` and ``<OtherWidget>`` rules to it - it does not
+            apply the ``width: 124`` rule. The ``width: 124`` rule is part of
+            the ``MyBox`` rule and is applied by the ``MyBox``'s instance's
+            :meth:`apply_class_lang_rules`.
+
+        .. versionchanged:: 1.11.0
+        '''
+        Builder.apply(
+            self, ignored_consts=ignored_consts,
+            rule_children=rule_children)
+
+    #
+    # Collision
+    #
+    def collide_point(self, x, y):
+        '''
+        Check if a point (x, y) is inside the widget's axis aligned bounding
+        box.
+
+        :Parameters:
+            `x`: numeric
+                x position of the point (in parent coordinates)
+            `y`: numeric
+                y position of the point (in parent coordinates)
+
+        :Returns:
+            A bool. True if the point is inside the bounding box, False
+            otherwise.
+
+        .. code-block:: python
+
+            >>> Widget(pos=(10, 10), size=(50, 50)).collide_point(40, 40)
+            True
+        '''
+        return self.x <= x <= self.right and self.y <= y <= self.top
+
+    def collide_widget(self, wid):
+        '''
+        Check if another widget collides with this widget. This function
+        performs an axis-aligned bounding box intersection test by default.
+
+        :Parameters:
+            `wid`: :class:`Widget` class
+                Widget to test collision with.
+
+        :Returns:
+            bool. True if the other widget collides with this widget, False
+            otherwise.
+
+        .. code-block:: python
+
+            >>> wid = Widget(size=(50, 50))
+            >>> wid2 = Widget(size=(50, 50), pos=(25, 25))
+            >>> wid.collide_widget(wid2)
+            True
+            >>> wid2.pos = (55, 55)
+            >>> wid.collide_widget(wid2)
+            False
+        '''
+        if self.right < wid.x:
+            return False
+        if self.x > wid.right:
+            return False
+        if self.top < wid.y:
+            return False
+        if self.y > wid.top:
+            return False
+        return True
+
+    def on_motion(self, etype, me):
+        '''Called when a motion event is received.
+
+        :Parameters:
+            `etype`: `str`
+                Event type, one of "begin", "update" or "end"
+            `me`: :class:`~kivy.input.motionevent.MotionEvent`
+                Received motion event
+        :Returns: `bool`
+            `True` to stop event dispatching
+
+        .. versionadded:: 2.1.0
+
+        .. warning::
+            This is an experimental method and it remains so while this warning
+            is present.
+        '''
+        if self.disabled or me.dispatch_mode == MODE_DONT_DISPATCH:
+            return
+        if me.type_id not in self.motion_filter:
+            return
+        filtered = self.motion_filter[me.type_id]
+        if filtered[0] is self and len(filtered) == 1:
+            return
+        if me.dispatch_mode == MODE_DEFAULT_DISPATCH:
+            last_filtered = filtered[-1]
+            for widget in self.children[:]:
+                if widget.dispatch('on_motion', etype, me):
+                    return True
+                if widget is last_filtered:
+                    return
+        if me.dispatch_mode == MODE_FILTERED_DISPATCH:
+            widgets = filtered[1:] if filtered[0] is self else filtered[:]
+            for widget in widgets:
+                if widget.dispatch('on_motion', etype, me):
+                    return True
+
+    #
+    # Default event handlers
+    #
+    def on_touch_down(self, touch):
+        '''Receive a touch down event.
+
+        :Parameters:
+            `touch`: :class:`~kivy.input.motionevent.MotionEvent` class
+                Touch received. The touch is in parent coordinates. See
+                :mod:`~kivy.uix.relativelayout` for a discussion on
+                coordinate systems.
+
+        :Returns: bool
+            If True, the dispatching of the touch event will stop.
+            If False, the event will continue to be dispatched to the rest
+            of the widget tree.
+        '''
+        if self.disabled and self.collide_point(*touch.pos):
+            return True
+        for child in self.children[:]:
+            if child.dispatch('on_touch_down', touch):
+                return True
+
+    def on_touch_move(self, touch):
+        '''Receive a touch move event. The touch is in parent coordinates.
+
+        See :meth:`on_touch_down` for more information.
+        '''
+        if self.disabled:
+            return
+        for child in self.children[:]:
+            if child.dispatch('on_touch_move', touch):
+                return True
+
+    def on_touch_up(self, touch):
+        '''Receive a touch up event. The touch is in parent coordinates.
+
+        See :meth:`on_touch_down` for more information.
+        '''
+        if self.disabled:
+            return
+        for child in self.children[:]:
+            if child.dispatch('on_touch_up', touch):
+                return True
+
+    def on_kv_post(self, base_widget):
+        pass
+
+    #
+    # Tree management
+    #
+    def add_widget(self, widget, index=0, canvas=None):
+        '''Add a new widget as a child of this widget.
+
+        :Parameters:
+            `widget`: :class:`Widget`
+                Widget to add to our list of children.
+            `index`: int, defaults to 0
+                Index to insert the widget in the list. Notice that the default
+                of 0 means the widget is inserted at the beginning of the list
+                and will thus be drawn on top of other sibling widgets. For a
+                full discussion of the index and widget hierarchy, please see
+                the :doc:`Widgets Programming Guide <guide/widgets>`.
+
+                .. versionadded:: 1.0.5
+            `canvas`: str, defaults to None
+                Canvas to add widget's canvas to. Can be 'before', 'after' or
+                None for the default canvas.
+
+                .. versionadded:: 1.9.0
+
+    .. code-block:: python
+
+        >>> from kivy.uix.button import Button
+        >>> from kivy.uix.slider import Slider
+        >>> root = Widget()
+        >>> root.add_widget(Button())
+        >>> slider = Slider()
+        >>> root.add_widget(slider)
+
+        '''
+        if not isinstance(widget, Widget):
+            raise WidgetException(
+                'add_widget() can be used only with instances'
+                ' of the Widget class.')
+
+        widget = widget.__self__
+        if widget is self:
+            raise WidgetException(
+                'Widget instances cannot be added to themselves.')
+        parent = widget.parent
+        # Check if the widget is already a child of another widget.
+        if parent:
+            raise WidgetException('Cannot add %r, it already has a parent %r'
+                                  % (widget, parent))
+        widget.parent = parent = self
+        # Child will be disabled if added to a disabled parent.
+        widget.inc_disabled(self._disabled_count)
+
+        canvas = self.canvas.before if canvas == 'before' else \
+            self.canvas.after if canvas == 'after' else self.canvas
+
+        if index == 0 or len(self.children) == 0:
+            self.children.insert(0, widget)
+            canvas.add(widget.canvas)
+        else:
+            canvas = self.canvas
+            children = self.children
+            if index >= len(children):
+                index = len(children)
+                next_index = canvas.indexof(children[-1].canvas)
+            else:
+                next_child = children[index]
+                next_index = canvas.indexof(next_child.canvas)
+                if next_index == -1:
+                    next_index = canvas.length()
+                else:
+                    next_index += 1
+
+            children.insert(index, widget)
+            # We never want to insert widget _before_ canvas.before.
+            if next_index == 0 and canvas.has_before:
+                next_index = 1
+            canvas.insert(next_index, widget.canvas)
+        for type_id in widget.motion_filter:
+            self.register_for_motion_event(type_id, widget)
+        widget.fbind('motion_filter', self._update_motion_filter)
+
+    def remove_widget(self, widget):
+        '''Remove a widget from the children of this widget.
+
+        :Parameters:
+            `widget`: :class:`Widget`
+                Widget to remove from our children list.
+
+    .. code-block:: python
+
+        >>> from kivy.uix.button import Button
+        >>> root = Widget()
+        >>> button = Button()
+        >>> root.add_widget(button)
+        >>> root.remove_widget(button)
+        '''
+        if widget not in self.children:
+            return
+        self.children.remove(widget)
+        if widget.canvas in self.canvas.children:
+            self.canvas.remove(widget.canvas)
+        elif widget.canvas in self.canvas.after.children:
+            self.canvas.after.remove(widget.canvas)
+        elif widget.canvas in self.canvas.before.children:
+            self.canvas.before.remove(widget.canvas)
+        for type_id in widget.motion_filter:
+            self.unregister_for_motion_event(type_id, widget)
+        widget.funbind('motion_filter', self._update_motion_filter)
+        widget.parent = None
+        widget.dec_disabled(self._disabled_count)
+
+    def clear_widgets(self, children=None):
+        '''
+        Remove all (or the specified) :attr:`~Widget.children` of this widget.
+        If the 'children' argument is specified, it should be a list (or
+        filtered list) of children of the current widget.
+
+        .. versionchanged:: 1.8.0
+            The `children` argument can be used to specify the children you
+            want to remove.
+        .. versionchanged:: 2.1.0
+
+            Specifying an empty ``children`` list leaves the widgets unchanged.
+            Previously it was treated like ``None`` and all children were
+            removed.
+        '''
+        if children is None or children is self.children:
+            children = self.children[:]
+
+        remove_widget = self.remove_widget
+        for child in children:
+            remove_widget(child)
+
+    def _update_motion_filter(self, child_widget, child_motion_filter):
+        old_events = []
+        for type_id, widgets in self.motion_filter.items():
+            if child_widget in widgets:
+                old_events.append(type_id)
+        for type_id in old_events:
+            if type_id not in child_motion_filter:
+                self.unregister_for_motion_event(type_id, child_widget)
+        for type_id in child_motion_filter:
+            if type_id not in old_events:
+                self.register_for_motion_event(type_id, child_widget)
+
+    def _find_index_in_motion_filter(self, type_id, widget):
+        if widget is self:
+            return 0
+        find_index = self.children.index
+        max_index = find_index(widget) + 1
+        motion_widgets = self.motion_filter[type_id]
+        insert_index = 1 if motion_widgets[0] is self else 0
+        for index in range(insert_index, len(motion_widgets)):
+            if find_index(motion_widgets[index]) < max_index:
+                insert_index += 1
+            else:
+                break
+        return insert_index
+
+    def register_for_motion_event(self, type_id, widget=None):
+        '''Register to receive motion events of `type_id`.
+
+        Override :meth:`on_motion` or bind to `on_motion` event to handle
+        the incoming motion events.
+
+        :Parameters:
+            `type_id`: `str`
+                Motion event type id (eg. "touch", "hover", etc.)
+            `widget`: `Widget`
+                Child widget or `self` if omitted
+
+        .. versionadded:: 2.1.0
+
+        .. note::
+            Method can be called multiple times with the same arguments.
+
+        .. warning::
+            This is an experimental method and it remains so while this warning
+            is present.
+        '''
+        a_widget = widget or self
+        motion_filter = self.motion_filter
+        if type_id not in motion_filter:
+            motion_filter[type_id] = [a_widget]
+        elif widget not in motion_filter[type_id]:
+            index = self._find_index_in_motion_filter(type_id, a_widget)
+            motion_filter[type_id].insert(index, a_widget)
+
+    def unregister_for_motion_event(self, type_id, widget=None):
+        '''Unregister to receive motion events of `type_id`.
+
+        :Parameters:
+            `type_id`: `str`
+                Motion event type id (eg. "touch", "hover", etc.)
+            `widget`: `Widget`
+                Child widget or `self` if omitted
+
+        .. versionadded:: 2.1.0
+
+        .. note::
+            Method can be called multiple times with the same arguments.
+
+        .. warning::
+            This is an experimental method and it remains so while this warning
+            is present.
+        '''
+        a_widget = widget or self
+        motion_filter = self.motion_filter
+        if type_id in motion_filter:
+            if a_widget in motion_filter[type_id]:
+                motion_filter[type_id].remove(a_widget)
+                if not motion_filter[type_id]:
+                    del motion_filter[type_id]
+
+    def export_to_png(self, filename, *args, **kwargs):
+        '''Saves an image of the widget and its children in png format at the
+        specified filename. Works by removing the widget canvas from its
+        parent, rendering to an :class:`~kivy.graphics.fbo.Fbo`, and calling
+        :meth:`~kivy.graphics.texture.Texture.save`.
+
+        .. note::
+
+            The image includes only this widget and its children. If you want
+            to include widgets elsewhere in the tree, you must call
+            :meth:`~Widget.export_to_png` from their common parent, or use
+            :meth:`~kivy.core.window.WindowBase.screenshot` to capture the
+            whole window.
+
+        .. note::
+
+            The image will be saved in png format, you should include the
+            extension in your filename.
+
+        .. versionadded:: 1.9.0
+
+        :Parameters:
+            `filename`: str
+                The filename with which to save the png.
+            `scale`: float
+                The amount by which to scale the saved image, defaults to 1.
+
+                .. versionadded:: 1.11.0
+        '''
+        self.export_as_image(*args, **kwargs).save(filename, flipped=False)
+
+    def export_as_image(self, *args, **kwargs):
+        '''Return an core :class:`~kivy.core.image.Image` of the actual
+        widget.
+
+        .. versionadded:: 1.11.0
+        '''
+        from kivy.core.image import Image
+        scale = kwargs.get('scale', 1)
+
+        if self.parent is not None:
+            canvas_parent_index = self.parent.canvas.indexof(self.canvas)
+            if canvas_parent_index > -1:
+                self.parent.canvas.remove(self.canvas)
+
+        fbo = Fbo(size=(self.width * scale, self.height * scale),
+                  with_stencilbuffer=True)
+
+        with fbo:
+            ClearColor(0, 0, 0, 0)
+            ClearBuffers()
+            Scale(1, -1, 1)
+            Scale(scale, scale, 1)
+            Translate(-self.x, -self.y - self.height, 0)
+
+        fbo.add(self.canvas)
+        fbo.draw()
+        img = Image(fbo.texture)
+        fbo.remove(self.canvas)
+
+        if self.parent is not None and canvas_parent_index > -1:
+            self.parent.canvas.insert(canvas_parent_index, self.canvas)
+
+        return img
+
+    def get_root_window(self):
+        '''Return the root window.
+
+        :Returns:
+            Instance of the root window. Can be a
+            :class:`~kivy.core.window.WindowBase` or
+            :class:`Widget`.
+        '''
+        if self.parent:
+            return self.parent.get_root_window()
+
+    def get_parent_window(self):
+        '''Return the parent window.
+
+        :Returns:
+            Instance of the parent window. Can be a
+            :class:`~kivy.core.window.WindowBase` or
+            :class:`Widget`.
+        '''
+        if self.parent:
+            return self.parent.get_parent_window()
+
+    def _walk(self, restrict=False, loopback=False, index=None):
+        # We pass index only when we are going on the parent
+        # so don't yield the parent as well.
+        if index is None:
+            index = len(self.children)
+            yield self
+
+        for child in reversed(self.children[:index]):
+            for walk_child in child._walk(restrict=True):
+                yield walk_child
+
+        # If we want to continue with our parent, just do it.
+        if not restrict:
+            parent = self.parent
+            try:
+                if parent is None or not isinstance(parent, Widget):
+                    raise ValueError
+                index = parent.children.index(self)
+            except ValueError:
+                # Self is root, if we want to loopback from the first element:
+                if not loopback:
+                    return
+                # If we started with root (i.e. index==None), then we have to
+                # start from root again, so we return self again. Otherwise, we
+                # never returned it, so return it now starting with it.
+                parent = self
+                index = None
+            for walk_child in parent._walk(loopback=loopback, index=index):
+                yield walk_child
+
+    def walk(self, restrict=False, loopback=False):
+        ''' Iterator that walks the widget tree starting with this widget and
+        goes forward returning widgets in the order in which layouts display
+        them.
+
+        :Parameters:
+            `restrict`: bool, defaults to False
+                If True, it will only iterate through the widget and its
+                children (or children of its children etc.). Defaults to False.
+            `loopback`: bool, defaults to False
+                If True, when the last widget in the tree is reached,
+                it'll loop back to the uppermost root and start walking until
+                we hit this widget again. Naturally, it can only loop back when
+                `restrict` is False. Defaults to False.
+
+        :return:
+            A generator that walks the tree, returning widgets in the
+            forward layout order.
+
+        For example, given a tree with the following structure:
+
+        .. code-block:: kv
+
+            GridLayout:
+                Button
+                BoxLayout:
+                    id: box
+                    Widget
+                    Button
+                Widget
+
+        walking this tree:
+
+        .. code-block:: python
+
+            >>> # Call walk on box with loopback True, and restrict False
+            >>> [type(widget) for widget in box.walk(loopback=True)]
+            [<class 'BoxLayout'>, <class 'Widget'>, <class 'Button'>,
+                <class 'Widget'>, <class 'GridLayout'>, <class 'Button'>]
+            >>> # Now with loopback False, and restrict False
+            >>> [type(widget) for widget in box.walk()]
+            [<class 'BoxLayout'>, <class 'Widget'>, <class 'Button'>,
+                <class 'Widget'>]
+            >>> # Now with restrict True
+            >>> [type(widget) for widget in box.walk(restrict=True)]
+            [<class 'BoxLayout'>, <class 'Widget'>, <class 'Button'>]
+
+        .. versionadded:: 1.9.0
+        '''
+        gen = self._walk(restrict, loopback)
+        yield next(gen)
+        for node in gen:
+            if node is self:
+                return
+            yield node
+
+    def _walk_reverse(self, loopback=False, go_up=False):
+        # process is walk up level, walk down its children tree, then walk up
+        # next level etc.
+        # default just walk down the children tree
+        root = self
+        index = 0
+        # we need to go up a level before walking tree
+        if go_up:
+            root = self.parent
+            try:
+                if root is None or not isinstance(root, Widget):
+                    raise ValueError
+                index = root.children.index(self) + 1
+            except ValueError:
+                if not loopback:
+                    return
+                index = 0
+                go_up = False
+                root = self
+
+        # now walk children tree starting with last-most child
+        for child in islice(root.children, index, None):
+            for walk_child in child._walk_reverse(loopback=loopback):
+                yield walk_child
+        # we need to return ourself last, in all cases
+        yield root
+
+        # if going up, continue walking up the parent tree
+        if go_up:
+            for walk_child in root._walk_reverse(loopback=loopback,
+                                                 go_up=go_up):
+                yield walk_child
+
+    def walk_reverse(self, loopback=False):
+        ''' Iterator that walks the widget tree backwards starting with the
+        widget before this, and going backwards returning widgets in the
+        reverse order in which layouts display them.
+
+        This walks in the opposite direction of :meth:`walk`, so a list of the
+        tree generated with :meth:`walk` will be in reverse order compared
+        to the list generated with this, provided `loopback` is True.
+
+        :Parameters:
+            `loopback`: bool, defaults to False
+                If True, when the uppermost root in the tree is
+                reached, it'll loop back to the last widget and start walking
+                back until after we hit widget again. Defaults to False.
+
+        :return:
+            A generator that walks the tree, returning widgets in the
+            reverse layout order.
+
+        For example, given a tree with the following structure:
+
+        .. code-block:: kv
+
+            GridLayout:
+                Button
+                BoxLayout:
+                    id: box
+                    Widget
+                    Button
+                Widget
+
+        walking this tree:
+
+        .. code-block:: python
+
+            >>> # Call walk on box with loopback True
+            >>> [type(widget) for widget in box.walk_reverse(loopback=True)]
+            [<class 'Button'>, <class 'GridLayout'>, <class 'Widget'>,
+                <class 'Button'>, <class 'Widget'>, <class 'BoxLayout'>]
+            >>> # Now with loopback False
+            >>> [type(widget) for widget in box.walk_reverse()]
+            [<class 'Button'>, <class 'GridLayout'>]
+            >>> forward = [w for w in box.walk(loopback=True)]
+            >>> backward = [w for w in box.walk_reverse(loopback=True)]
+            >>> forward == backward[::-1]
+            True
+
+        .. versionadded:: 1.9.0
+
+        '''
+        for node in self._walk_reverse(loopback=loopback, go_up=True):
+            yield node
+            if node is self:
+                return
+
+    def to_widget(self, x, y, relative=False):
+        '''Convert the coordinate from window to local (current widget)
+        coordinates.
+
+        See :mod:`~kivy.uix.relativelayout` for details on the coordinate
+        systems.
+        '''
+        if self.parent:
+            x, y = self.parent.to_widget(x, y)
+        return self.to_local(x, y, relative=relative)
+
+    def to_window(self, x, y, initial=True, relative=False):
+        """If ``initial`` is True, the default, it transforms **parent**
+        coordinates to window coordinates. Otherwise, it transforms **local**
+        (current widget) coordinates to window coordinates.
+
+        See :mod:`~kivy.uix.relativelayout` for details on the coordinate
+        systems.
+        """
+        if not initial:
+            x, y = self.to_parent(x, y, relative=relative)
+        if self.parent:
+            return self.parent.to_window(x, y, initial=False,
+                                         relative=relative)
+        return (x, y)
+
+    def to_parent(self, x, y, relative=False):
+        """Transform local (current widget) coordinates to parent coordinates.
+
+        See :mod:`~kivy.uix.relativelayout` for details on the coordinate
+        systems.
+
+        :Parameters:
+            `relative`: bool, defaults to False
+                Change to True if you want to translate relative positions from
+                a widget to its parent coordinates.
+        """
+        if relative:
+            return (x + self.x, y + self.y)
+        return (x, y)
+
+    def to_local(self, x, y, relative=False):
+        """Transform parent coordinates to local (current widget) coordinates.
+
+        See :mod:`~kivy.uix.relativelayout` for details on the coordinate
+        systems.
+
+        :Parameters:
+            `relative`: bool, defaults to False
+                Change to True if you want to translate coordinates to
+                relative widget coordinates.
+        """
+        if relative:
+            return (x - self.x, y - self.y)
+        return (x, y)
+
+    def _apply_transform(self, m, pos=None):
+        if self.parent:
+            x, y = self.parent.to_widget(relative=True,
+                                         *self.to_window(*(pos or self.pos)))
+            m.translate(x, y, 0)
+            m = self.parent._apply_transform(m) if self.parent else m
+        return m
+
+    def get_window_matrix(self, x=0, y=0):
+        '''Calculate the transformation matrix to convert between window and
+        widget coordinates.
+
+        :Parameters:
+            `x`: float, defaults to 0
+                Translates the matrix on the x axis.
+            `y`: float, defaults to 0
+                Translates the matrix on the y axis.
+        '''
+        m = Matrix()
+        m.translate(x, y, 0)
+        m = self._apply_transform(m)
+        return m
+
+    x = NumericProperty(0)
+    '''X position of the widget.
+
+    :attr:`x` is a :class:`~kivy.properties.NumericProperty` and defaults to 0.
+    '''
+
+    y = NumericProperty(0)
+    '''Y position of the widget.
+
+    :attr:`y` is a :class:`~kivy.properties.NumericProperty` and defaults to 0.
+    '''
+
+    width = NumericProperty(100)
+    '''Width of the widget.
+
+    :attr:`width` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 100.
+
+    .. warning::
+        Keep in mind that the `width` property is subject to layout logic and
+        that this has not yet happened at the time of the widget's `__init__`
+        method.
+
+    .. warning::
+        A negative width is not supported.
+    '''
+
+    height = NumericProperty(100)
+    '''Height of the widget.
+
+    :attr:`height` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 100.
+
+    .. warning::
+        Keep in mind that the `height` property is subject to layout logic and
+        that this has not yet happened at the time of the widget's `__init__`
+        method.
+
+    .. warning::
+        A negative height is not supported.
+    '''
+
+    pos = ReferenceListProperty(x, y)
+    '''Position of the widget.
+
+    :attr:`pos` is a :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`x`, :attr:`y`) properties.
+    '''
+
+    size = ReferenceListProperty(width, height)
+    '''Size of the widget.
+
+    :attr:`size` is a :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`width`, :attr:`height`) properties.
+    '''
+
+    def get_right(self):
+        return self.x + self.width
+
+    def set_right(self, value):
+        self.x = value - self.width
+
+    right = AliasProperty(get_right, set_right,
+                          bind=('x', 'width'),
+                          cache=True, watch_before_use=False)
+    '''Right position of the widget.
+
+    :attr:`right` is an :class:`~kivy.properties.AliasProperty` of
+    (:attr:`x` + :attr:`width`).
+    '''
+
+    def get_top(self):
+        return self.y + self.height
+
+    def set_top(self, value):
+        self.y = value - self.height
+
+    top = AliasProperty(get_top, set_top,
+                        bind=('y', 'height'),
+                        cache=True, watch_before_use=False)
+    '''Top position of the widget.
+
+    :attr:`top` is an :class:`~kivy.properties.AliasProperty` of
+    (:attr:`y` + :attr:`height`).
+    '''
+
+    def get_center_x(self):
+        return self.x + self.width / 2.
+
+    def set_center_x(self, value):
+        self.x = value - self.width / 2.
+
+    center_x = AliasProperty(get_center_x, set_center_x,
+                             bind=('x', 'width'),
+                             cache=True, watch_before_use=False)
+    '''X center position of the widget.
+
+    :attr:`center_x` is an :class:`~kivy.properties.AliasProperty` of
+    (:attr:`x` + :attr:`width` / 2.).
+    '''
+
+    def get_center_y(self):
+        return self.y + self.height / 2.
+
+    def set_center_y(self, value):
+        self.y = value - self.height / 2.
+
+    center_y = AliasProperty(get_center_y, set_center_y,
+                             bind=('y', 'height'),
+                             cache=True, watch_before_use=False)
+    '''Y center position of the widget.
+
+    :attr:`center_y` is an :class:`~kivy.properties.AliasProperty` of
+    (:attr:`y` + :attr:`height` / 2.).
+    '''
+
+    center = ReferenceListProperty(center_x, center_y)
+    '''Center position of the widget.
+
+    :attr:`center` is a :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`center_x`, :attr:`center_y`) properties.
+    '''
+
+    cls = ListProperty([])
+    '''Class of the widget, used for styling.
+    '''
+
+    children = ListProperty([])
+    '''List of children of this widget.
+
+    :attr:`children` is a :class:`~kivy.properties.ListProperty` and
+    defaults to an empty list.
+
+    Use :meth:`add_widget` and :meth:`remove_widget` for manipulating the
+    children list. Don't manipulate the children list directly unless you know
+    what you are doing.
+    '''
+
+    parent = ObjectProperty(None, allownone=True, rebind=True)
+    '''Parent of this widget. The parent of a widget is set when the widget
+    is added to another widget and unset when the widget is removed from its
+    parent.
+
+    :attr:`parent` is an :class:`~kivy.properties.ObjectProperty` and
+    defaults to None.
+    '''
+
+    size_hint_x = NumericProperty(1, allownone=True)
+    '''x size hint. Represents how much space the widget should use in the
+    direction of the x axis relative to its parent's width.
+    Only the :class:`~kivy.uix.layout.Layout` and
+    :class:`~kivy.core.window.Window` classes make use of the hint.
+
+    The size_hint is used by layouts for two purposes:
+
+    - When the layout considers widgets on their own rather than in
+      relation to its other children, the size_hint_x is a direct proportion
+      of the parent width, normally between 0.0 and 1.0. For instance, a
+      widget with ``size_hint_x=0.5`` in
+      a vertical BoxLayout will take up half the BoxLayout's width, or
+      a widget in a FloatLayout with ``size_hint_x=0.2`` will take up 20%
+      of the FloatLayout width. If the size_hint is greater than 1, the
+      widget will be wider than the parent.
+    - When multiple widgets can share a row of a layout, such as in a
+      horizontal BoxLayout, their widths will be their size_hint_x as a
+      fraction of the sum of widget size_hints. For instance, if the
+      size_hint_xs are (0.5, 1.0, 0.5), the first widget will have a
+      width of 25% of the parent width.
+
+    :attr:`size_hint_x` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+    '''
+
+    size_hint_y = NumericProperty(1, allownone=True)
+    '''y size hint.
+
+    :attr:`size_hint_y` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to 1.
+
+    See :attr:`size_hint_x` for more information, but with widths and heights
+    swapped.
+    '''
+
+    size_hint = ReferenceListProperty(size_hint_x, size_hint_y)
+    '''Size hint.
+
+    :attr:`size_hint` is a :class:`~kivy.properties.ReferenceListProperty` of
+    (:attr:`size_hint_x`, :attr:`size_hint_y`) properties.
+
+    See :attr:`size_hint_x` for more information.
+    '''
+
+    pos_hint = ObjectProperty({})
+    '''Position hint. This property allows you to set the position of
+    the widget inside its parent layout (similar to
+    size_hint).
+
+    For example, if you want to set the top of the widget to be at 90%
+    height of its parent layout, you can write::
+
+        widget = Widget(pos_hint={'top': 0.9})
+
+    The keys 'x', 'right' and 'center_x' will use the parent width.
+    The keys 'y', 'top' and 'center_y' will use the parent height.
+
+    See :doc:`api-kivy.uix.floatlayout` for further reference.
+
+    .. note::
+        :attr:`pos_hint` is not used by all layouts. Check the documentation
+        of the layout in question to see if it supports pos_hint.
+
+    :attr:`pos_hint` is an :class:`~kivy.properties.ObjectProperty`
+    containing a dict.
+    '''
+
+    size_hint_min_x = NumericProperty(None, allownone=True)
+    '''When not None, the x-direction minimum size (in pixels,
+    like :attr:`width`) when :attr:`size_hint_x` is also not None.
+
+    When :attr:`size_hint_x` is not None, it is the minimum width that the
+    widget will be set due to the :attr:`size_hint_x`. I.e. when a smaller size
+    would be set, :attr:`size_hint_min_x` is the value used instead for the
+    widget width. When None, or when :attr:`size_hint_x` is None,
+    :attr:`size_hint_min_x` doesn't do anything.
+
+    Only the :class:`~kivy.uix.layout.Layout` and
+    :class:`~kivy.core.window.Window` classes make use of the hint.
+
+    :attr:`size_hint_min_x` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to None.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    size_hint_min_y = NumericProperty(None, allownone=True)
+    '''When not None, the y-direction minimum size (in pixels,
+    like :attr:`height`) when :attr:`size_hint_y` is also not None.
+
+    When :attr:`size_hint_y` is not None, it is the minimum height that the
+    widget will be set due to the :attr:`size_hint_y`. I.e. when a smaller size
+    would be set, :attr:`size_hint_min_y` is the value used instead for the
+    widget height. When None, or when :attr:`size_hint_y` is None,
+    :attr:`size_hint_min_y` doesn't do anything.
+
+    Only the :class:`~kivy.uix.layout.Layout` and
+    :class:`~kivy.core.window.Window` classes make use of the hint.
+
+    :attr:`size_hint_min_y` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to None.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    size_hint_min = ReferenceListProperty(size_hint_min_x, size_hint_min_y)
+    '''Minimum size when using :attr:`size_hint`.
+
+    :attr:`size_hint_min` is a :class:`~kivy.properties.ReferenceListProperty`
+    of (:attr:`size_hint_min_x`, :attr:`size_hint_min_y`) properties.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    size_hint_max_x = NumericProperty(None, allownone=True)
+    '''When not None, the x-direction maximum size (in pixels,
+    like :attr:`width`) when :attr:`size_hint_x` is also not None.
+
+    Similar to :attr:`size_hint_min_x`, except that it sets the maximum width.
+
+    :attr:`size_hint_max_x` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to None.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    size_hint_max_y = NumericProperty(None, allownone=True)
+    '''When not None, the y-direction maximum size (in pixels,
+    like :attr:`height`) when :attr:`size_hint_y` is also not None.
+
+    Similar to :attr:`size_hint_min_y`, except that it sets the maximum height.
+
+    :attr:`size_hint_max_y` is a :class:`~kivy.properties.NumericProperty` and
+    defaults to None.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    size_hint_max = ReferenceListProperty(size_hint_max_x, size_hint_max_y)
+    '''Maximum size when using :attr:`size_hint`.
+
+    :attr:`size_hint_max` is a :class:`~kivy.properties.ReferenceListProperty`
+    of (:attr:`size_hint_max_x`, :attr:`size_hint_max_y`) properties.
+
+    .. versionadded:: 1.10.0
+    '''
+
+    ids = DictProperty({})
+    '''This is a dictionary of ids defined in your kv language. This will only
+    be populated if you use ids in your kv language code.
+
+    .. versionadded:: 1.7.0
+
+    :attr:`ids` is a :class:`~kivy.properties.DictProperty` and defaults to an
+    empty dict {}.
+
+    The :attr:`ids` are populated for each root level widget definition. For
+    example:
+
+    .. code-block:: kv
+
+        # in kv
+        <MyWidget@Widget>:
+            id: my_widget
+            Label:
+                id: label_widget
+                Widget:
+                    id: inner_widget
+                    Label:
+                        id: inner_label
+            TextInput:
+                id: text_input
+            OtherWidget:
+                id: other_widget
+
+
+        <OtherWidget@Widget>
+            id: other_widget
+            Label:
+                id: other_label
+                TextInput:
+                    id: other_textinput
+
+    Then, in python:
+
+    .. code-block:: python
+
+        >>> widget = MyWidget()
+        >>> print(widget.ids)
+        {'other_widget': <weakproxy at 041CFED0 to OtherWidget at 041BEC38>,
+        'inner_widget': <weakproxy at 04137EA0 to Widget at 04138228>,
+        'inner_label': <weakproxy at 04143540 to Label at 04138260>,
+        'label_widget': <weakproxy at 04137B70 to Label at 040F97A0>,
+        'text_input': <weakproxy at 041BB5D0 to TextInput at 041BEC00>}
+        >>> print(widget.ids['other_widget'].ids)
+        {'other_textinput': <weakproxy at 041DBB40 to TextInput at 041BEF48>,
+        'other_label': <weakproxy at 041DB570 to Label at 041BEEA0>}
+        >>> print(widget.ids['label_widget'].ids)
+        {}
+    '''
+
+    opacity = NumericProperty(1.0)
+    '''Opacity of the widget and all its children.
+
+    .. versionadded:: 1.4.1
+
+    The opacity attribute controls the opacity of the widget and its children.
+    Be careful, it's a cumulative attribute: the value is multiplied by the
+    current global opacity and the result is applied to the current context
+    color.
+
+    For example, if the parent has an opacity of 0.5 and a child has an
+    opacity of 0.2, the real opacity of the child will be 0.5 * 0.2 = 0.1.
+
+    Then, the opacity is applied by the shader as:
+
+    .. code-block:: python
+
+        frag_color = color * vec4(1.0, 1.0, 1.0, opacity);
+
+    :attr:`opacity` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.0.
+    '''
+
+    def on_opacity(self, instance, value):
+        canvas = self.canvas
+        if canvas is not None:
+            canvas.opacity = value
+
+    canvas = None
+    '''Canvas of the widget.
+
+    The canvas is a graphics object that contains all the drawing instructions
+    for the graphical representation of the widget.
+
+    There are no general properties for the Widget class, such as background
+    color, to keep the design simple and lean. Some derived classes, such as
+    Button, do add such convenience properties but generally the developer is
+    responsible for implementing the graphics representation for a custom
+    widget from the ground up. See the derived widget classes for patterns to
+    follow and extend.
+
+    See :class:`~kivy.graphics.Canvas` for more information about the usage.
+    '''
+
+    def get_disabled(self):
+        return self._disabled_count > 0
+
+    def set_disabled(self, value):
+        # Necessary to ensure a change between value of equal truthiness
+        # doesn't mess up the count
+        value = bool(value)
+        if value != self._disabled_value:
+            self._disabled_value = value
+            if value:
+                self.inc_disabled()
+            else:
+                self.dec_disabled()
+            return True
+
+    def inc_disabled(self, count=1):
+        self._disabled_count += count
+        if self._disabled_count - count < 1 <= self._disabled_count:
+            self.property('disabled').dispatch(self)
+        for c in self.children:
+            c.inc_disabled(count)
+
+    def dec_disabled(self, count=1):
+        self._disabled_count -= count
+        if self._disabled_count <= 0 < self._disabled_count + count:
+            self.property('disabled').dispatch(self)
+        for c in self.children:
+            c.dec_disabled(count)
+
+    disabled = AliasProperty(get_disabled, set_disabled, watch_before_use=False)
+    '''Indicates whether this widget can interact with input or not.
+
+    :attr:`disabled` is an :class:`~kivy.properties.AliasProperty` and
+    defaults to False.
+
+    .. note::
+
+      1. Child Widgets, when added to a disabled widget, will be disabled
+         automatically.
+      2. Disabling/enabling a parent disables/enables all
+         of its children.
+
+    .. versionadded:: 1.8.0
+
+    .. versionchanged:: 1.10.1
+
+        :attr:`disabled` was changed from a
+        :class:`~kivy.properties.BooleanProperty` to an
+        :class:`~kivy.properties.AliasProperty` to allow access to its
+        previous state when a parent's disabled state is changed.
+    '''
+
+    motion_filter = DictProperty()
+    '''Holds a dict of `type_id` to `list` of child widgets registered to
+    receive motion events of `type_id`.
+
+    Don't change the property directly but use
+    :meth:`register_for_motion_event` and :meth:`unregister_for_motion_event`
+    to register and unregister for motion events. If `self` is registered it
+    will always be the first element in the list.
+
+    .. versionadded:: 2.1.0
+
+    .. warning::
+        This is an experimental property and it remains so while this warning
+        is present.
+    '''
diff --git a/kivy/utils.py b/kivy/utils.py
new file mode 100644
index 0000000..2a5c718
--- /dev/null
+++ b/kivy/utils.py
@@ -0,0 +1,549 @@
+# pylint: disable=W0611
+'''
+Utils
+=====
+
+The Utils module provides a selection of general utility functions and classes
+that may be useful for various applications. These include maths, color,
+algebraic and platform functions.
+
+.. versionchanged:: 1.6.0
+    The OrderedDict class has been removed. Use collections.OrderedDict
+    instead.
+
+'''
+
+__all__ = ('intersection', 'difference', 'strtotuple',
+           'get_color_from_hex', 'get_hex_from_color', 'get_random_color',
+           'is_color_transparent', 'hex_colormap', 'colormap', 'boundary',
+           'deprecated', 'SafeList',
+           'interpolate', 'QueryDict',
+           'platform', 'escape_markup', 'reify', 'rgba', 'pi_version')
+
+from os import environ, path
+from sys import platform as _sys_platform
+from re import match, split, search, MULTILINE, IGNORECASE
+from kivy.compat import string_types
+
+
+def boundary(value, minvalue, maxvalue):
+    '''Limit a value between a minvalue and maxvalue.'''
+    return min(max(value, minvalue), maxvalue)
+
+
+def intersection(set1, set2):
+    '''Return the intersection of 2 lists.'''
+    return [s for s in set1 if s in set2]
+
+
+def difference(set1, set2):
+    '''Return the difference between 2 lists.'''
+    return [s for s in set1 if s not in set2]
+
+
+def interpolate(value_from, value_to, step=10):
+    '''Interpolate between two values. This can be useful for smoothing some
+    transitions. For example::
+
+        # instead of setting directly
+        self.pos = pos
+
+        # use interpolate, and you'll have a nicer transition
+        self.pos = interpolate(self.pos, new_pos)
+
+    .. warning::
+        These interpolations work only on lists/tuples/doubles with the same
+        dimensions. No test is done to check the dimensions are the same.
+    '''
+    if type(value_from) in (list, tuple):
+        out = []
+        for x, y in zip(value_from, value_to):
+            out.append(interpolate(x, y, step))
+        return out
+    else:
+        return value_from + (value_to - value_from) / float(step)
+
+
+def strtotuple(s):
+    '''Convert a tuple string into a tuple
+    with some security checks. Designed to be used
+    with the eval() function::
+
+        a = (12, 54, 68)
+        b = str(a)         # return '(12, 54, 68)'
+        c = strtotuple(b)  # return (12, 54, 68)
+
+    '''
+    # security
+    if not match(r'^[,.0-9 ()\[\]]*$', s):
+        raise Exception('Invalid characters in string for tuple conversion')
+    # fast syntax check
+    if s.count('(') != s.count(')'):
+        raise Exception('Invalid count of ( and )')
+    if s.count('[') != s.count(']'):
+        raise Exception('Invalid count of [ and ]')
+    r = eval(s)
+    if type(r) not in (list, tuple):
+        raise Exception('Conversion failed')
+    return r
+
+
+def rgba(s, *args):
+    '''Return a Kivy color (4 value from 0-1 range) from either a hex string or
+    a list of 0-255 values.
+
+    .. versionadded:: 1.10.0
+    '''
+    if isinstance(s, string_types):
+        return get_color_from_hex(s)
+    if isinstance(s, (list, tuple)):
+        s = [x / 255. for x in s]
+        if len(s) == 3:
+            s.append(1)
+        return s
+    if isinstance(s, (int, float)):
+        s = [s / 255.]
+        s.extend(x / 255. for x in args)
+        if len(s) == 3:
+            s.append(1)
+        return s
+    raise Exception('Invalid value (not a string / list / tuple)')
+
+
+def get_color_from_hex(s):
+    '''Transform a hex string color to a kivy
+    :class:`~kivy.graphics.Color`.
+    '''
+    if s.startswith('#'):
+        return get_color_from_hex(s[1:])
+
+    value = [int(x, 16) / 255.
+             for x in split('([0-9a-f]{2})', s.lower()) if x != '']
+    if len(value) == 3:
+        value.append(1.0)
+    return value
+
+
+def get_hex_from_color(color):
+    '''Transform a kivy :class:`~kivy.graphics.Color` to a hex value::
+
+        >>> get_hex_from_color((0, 1, 0))
+        '#00ff00'
+        >>> get_hex_from_color((.25, .77, .90, .5))
+        '#3fc4e57f'
+
+    .. versionadded:: 1.5.0
+    '''
+    return '#' + ''.join(['{0:02x}'.format(int(x * 255)) for x in color])
+
+
+def get_random_color(alpha=1.0):
+    '''Returns a random color (4 tuple).
+
+    :Parameters:
+        `alpha`: float, defaults to 1.0
+            If alpha == 'random', a random alpha value is generated.
+    '''
+    from random import random
+    if alpha == 'random':
+        return [random(), random(), random(), random()]
+    else:
+        return [random(), random(), random(), alpha]
+
+
+def is_color_transparent(c):
+    '''Return True if the alpha channel is 0.'''
+    if len(c) < 4:
+        return False
+    if float(c[3]) == 0.:
+        return True
+    return False
+
+
+hex_colormap = {
+    'aliceblue': '#f0f8ff',
+    'antiquewhite': '#faebd7',
+    'aqua': '#00ffff',
+    'aquamarine': '#7fffd4',
+    'azure': '#f0ffff',
+    'beige': '#f5f5dc',
+    'bisque': '#ffe4c4',
+    'black': '#000000',
+    'blanchedalmond': '#ffebcd',
+    'blue': '#0000ff',
+    'blueviolet': '#8a2be2',
+    'brown': '#a52a2a',
+    'burlywood': '#deb887',
+    'cadetblue': '#5f9ea0',
+    'chartreuse': '#7fff00',
+    'chocolate': '#d2691e',
+    'coral': '#ff7f50',
+    'cornflowerblue': '#6495ed',
+    'cornsilk': '#fff8dc',
+    'crimson': '#dc143c',
+    'cyan': '#00ffff',
+    'darkblue': '#00008b',
+    'darkcyan': '#008b8b',
+    'darkgoldenrod': '#b8860b',
+    'darkgray': '#a9a9a9',
+    'darkgrey': '#a9a9a9',
+    'darkgreen': '#006400',
+    'darkkhaki': '#bdb76b',
+    'darkmagenta': '#8b008b',
+    'darkolivegreen': '#556b2f',
+    'darkorange': '#ff8c00',
+    'darkorchid': '#9932cc',
+    'darkred': '#8b0000',
+    'darksalmon': '#e9967a',
+    'darkseagreen': '#8fbc8f',
+    'darkslateblue': '#483d8b',
+    'darkslategray': '#2f4f4f',
+    'darkslategrey': '#2f4f4f',
+    'darkturquoise': '#00ced1',
+    'darkviolet': '#9400d3',
+    'deeppink': '#ff1493',
+    'deepskyblue': '#00bfff',
+    'dimgray': '#696969',
+    'dimgrey': '#696969',
+    'dodgerblue': '#1e90ff',
+    'firebrick': '#b22222',
+    'floralwhite': '#fffaf0',
+    'forestgreen': '#228b22',
+    'fuchsia': '#ff00ff',
+    'gainsboro': '#dcdcdc',
+    'ghostwhite': '#f8f8ff',
+    'gold': '#ffd700',
+    'goldenrod': '#daa520',
+    'gray': '#808080',
+    'grey': '#808080',
+    'green': '#008000',
+    'greenyellow': '#adff2f',
+    'honeydew': '#f0fff0',
+    'hotpink': '#ff69b4',
+    'indianred': '#cd5c5c',
+    'indigo': '#4b0082',
+    'ivory': '#fffff0',
+    'khaki': '#f0e68c',
+    'lavender': '#e6e6fa',
+    'lavenderblush': '#fff0f5',
+    'lawngreen': '#7cfc00',
+    'lemonchiffon': '#fffacd',
+    'lightblue': '#add8e6',
+    'lightcoral': '#f08080',
+    'lightcyan': '#e0ffff',
+    'lightgoldenrodyellow': '#fafad2',
+    'lightgreen': '#90ee90',
+    'lightgray': '#d3d3d3',
+    'lightgrey': '#d3d3d3',
+    'lightpink': '#ffb6c1',
+    'lightsalmon': '#ffa07a',
+    'lightseagreen': '#20b2aa',
+    'lightskyblue': '#87cefa',
+    'lightslategray': '#778899',
+    'lightslategrey': '#778899',
+    'lightsteelblue': '#b0c4de',
+    'lightyellow': '#ffffe0',
+    'lime': '#00ff00',
+    'limegreen': '#32cd32',
+    'linen': '#faf0e6',
+    'magenta': '#ff00ff',
+    'maroon': '#800000',
+    'mediumaquamarine': '#66cdaa',
+    'mediumblue': '#0000cd',
+    'mediumorchid': '#ba55d3',
+    'mediumpurple': '#9370db',
+    'mediumseagreen': '#3cb371',
+    'mediumslateblue': '#7b68ee',
+    'mediumspringgreen': '#00fa9a',
+    'mediumturquoise': '#48d1cc',
+    'mediumvioletred': '#c71585',
+    'midnightblue': '#191970',
+    'mintcream': '#f5fffa',
+    'mistyrose': '#ffe4e1',
+    'moccasin': '#ffe4b5',
+    'navajowhite': '#ffdead',
+    'navy': '#000080',
+    'oldlace': '#fdf5e6',
+    'olive': '#808000',
+    'olivedrab': '#6b8e23',
+    'orange': '#ffa500',
+    'orangered': '#ff4500',
+    'orchid': '#da70d6',
+    'palegoldenrod': '#eee8aa',
+    'palegreen': '#98fb98',
+    'paleturquoise': '#afeeee',
+    'palevioletred': '#db7093',
+    'papayawhip': '#ffefd5',
+    'peachpuff': '#ffdab9',
+    'peru': '#cd853f',
+    'pink': '#ffc0cb',
+    'plum': '#dda0dd',
+    'powderblue': '#b0e0e6',
+    'purple': '#800080',
+    'red': '#ff0000',
+    'rosybrown': '#bc8f8f',
+    'royalblue': '#4169e1',
+    'saddlebrown': '#8b4513',
+    'salmon': '#fa8072',
+    'sandybrown': '#f4a460',
+    'seagreen': '#2e8b57',
+    'seashell': '#fff5ee',
+    'sienna': '#a0522d',
+    'silver': '#c0c0c0',
+    'skyblue': '#87ceeb',
+    'slateblue': '#6a5acd',
+    'slategray': '#708090',
+    'slategrey': '#708090',
+    'snow': '#fffafa',
+    'springgreen': '#00ff7f',
+    'steelblue': '#4682b4',
+    'tan': '#d2b48c',
+    'teal': '#008080',
+    'thistle': '#d8bfd8',
+    'tomato': '#ff6347',
+    'turquoise': '#40e0d0',
+    'violet': '#ee82ee',
+    'wheat': '#f5deb3',
+    'white': '#ffffff',
+    'whitesmoke': '#f5f5f5',
+    'yellow': '#ffff00',
+    'yellowgreen': '#9acd32',
+}
+
+colormap = {k: get_color_from_hex(v) for k, v in hex_colormap.items()}
+
+DEPRECATED_CALLERS = []
+
+
+def deprecated(func=None, msg=''):
+    '''This is a decorator which can be used to mark functions
+    as deprecated. It will result in a warning being emitted the first time
+    the function is used.'''
+
+    import inspect
+    import functools
+
+    if func is None:
+        return functools.partial(deprecated, msg=msg)
+
+    @functools.wraps(func)
+    def new_func(*args, **kwargs):
+        file, line, caller = inspect.stack()[1][1:4]
+        caller_id = "%s:%s:%s" % (file, line, caller)
+        # We want to print deprecated warnings only once:
+        if caller_id not in DEPRECATED_CALLERS:
+            DEPRECATED_CALLERS.append(caller_id)
+            warning = (
+                'Call to deprecated function %s in %s line %d.'
+                'Called from %s line %d'
+                ' by %s().' % (
+                    func.__name__,
+                    func.__code__.co_filename,
+                    func.__code__.co_firstlineno + 1,
+                    file, line, caller))
+
+            if msg:
+                warning = '{}: {}'.format(msg, warning)
+            warning = 'Deprecated: ' + warning
+
+            from kivy.logger import Logger
+            Logger.warning(warning)
+            if func.__doc__:
+                Logger.warning(func.__doc__)
+        return func(*args, **kwargs)
+    return new_func
+
+
+class SafeList(list):
+    '''List with a clear() method.
+
+    .. warning::
+        Usage of the iterate() function will decrease your performance.
+    '''
+
+    @deprecated
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def clear(self):
+        del self[:]
+
+    @deprecated
+    def iterate(self, reverse=False):
+        if reverse:
+            return iter(reversed(self))
+        return iter(self)
+
+
+class QueryDict(dict):
+    '''QueryDict is a dict() that can be queried with dot.
+
+    ::
+
+        d = QueryDict()
+        # create a key named toto, with the value 1
+        d.toto = 1
+        # it's the same as
+        d['toto'] = 1
+
+    .. versionadded:: 1.0.4
+    '''
+
+    def __getattr__(self, attr):
+        try:
+            return self.__getitem__(attr)
+        except KeyError:
+            return super(QueryDict, self).__getattr__(attr)
+
+    def __setattr__(self, attr, value):
+        self.__setitem__(attr, value)
+
+
+def format_bytes_to_human(size, precision=2):
+    '''Format a byte value to a human readable representation (B, KB, MB...).
+
+    .. versionadded:: 1.0.8
+
+    :Parameters:
+        `size`: int
+            Number that represents the bytes value
+        `precision`: int, defaults to 2
+            Precision after the comma
+
+    Examples::
+
+        >>> format_bytes_to_human(6463)
+        '6.31 KB'
+        >>> format_bytes_to_human(646368746541)
+        '601.98 GB'
+
+    '''
+    size = int(size)
+    fmt = '%%1.%df %%s' % precision
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size < 1024.0:
+            return fmt % (size, unit)
+        size /= 1024.0
+
+
+def _get_platform():
+    # On Android sys.platform returns 'linux2', so prefer to check the
+    # existence of environ variables set during Python initialization
+    kivy_build = environ.get('KIVY_BUILD', '')
+    if kivy_build in {'android', 'ios'}:
+        return kivy_build
+    elif 'P4A_BOOTSTRAP' in environ:
+        return 'android'
+    elif 'ANDROID_ARGUMENT' in environ:
+        # We used to use this method to detect android platform,
+        # leaving it here to be backwards compatible with `pydroid3`
+        # and similar tools outside kivy's ecosystem
+        return 'android'
+    elif _sys_platform in ('win32', 'cygwin'):
+        return 'win'
+    elif _sys_platform == 'darwin':
+        return 'macosx'
+    elif _sys_platform.startswith('linux'):
+        return 'linux'
+    elif _sys_platform.startswith('freebsd'):
+        return 'linux'
+    return 'unknown'
+
+
+platform = _get_platform()
+'''
+A string identifying the current operating system. It is one
+of: `'win'`, `'linux'`, `'android'`, `'macosx'`, `'ios'` or `'unknown'`.
+You can use it as follows::
+
+    from kivy.utils import platform
+    if platform == 'linux':
+        do_linux_things()
+
+.. versionadded:: 1.3.0
+
+.. versionchanged:: 1.8.0
+
+    platform is now a variable instead of a function.
+'''
+
+
+def escape_markup(text):
+    '''
+    Escape markup characters found in the text. Intended to be used when markup
+    text is activated on the Label::
+
+        untrusted_text = escape_markup('Look at the example [1]')
+        text = '[color=ff0000]' + untrusted_text + '[/color]'
+        w = Label(text=text, markup=True)
+
+    .. versionadded:: 1.3.0
+    '''
+    return text.replace('&', '&amp;').replace('[', '&bl;').replace(']', '&br;')
+
+
+class reify(object):
+    '''
+    Put the result of a method which uses this (non-data) descriptor decorator
+    in the instance dict after the first call, effectively replacing the
+    decorator with an instance variable.
+
+    It acts like @property, except that the function is only ever called once;
+    after that, the value is cached as a regular attribute. This gives you lazy
+    attribute creation on objects that are meant to be immutable.
+
+    Taken from the `Pyramid project <https://pypi.python.org/pypi/pyramid/>`_.
+
+    To use this as a decorator::
+
+         @reify
+         def lazy(self):
+              ...
+              return hard_to_compute_int
+         first_time = self.lazy   # lazy is reify obj, reify.__get__() runs
+         second_time = self.lazy  # lazy is hard_to_compute_int
+    '''
+
+    def __init__(self, func):
+        self.func = func
+        self.__doc__ = func.__doc__
+
+    def __get__(self, inst, cls):
+        if inst is None:
+            return self
+        retval = self.func(inst)
+        setattr(inst, self.func.__name__, retval)
+        return retval
+
+
+def _get_pi_version():
+    """Detect the version of the Raspberry Pi by reading the revision field value from '/proc/cpuinfo'
+    See: https://www.raspberrypi.org/documentation/hardware/raspberrypi/revision-codes/README.md
+    Based on: https://github.com/adafruit/Adafruit_Python_GPIO/blob/master/Adafruit_GPIO/Platform.py
+    """  # noqa
+    # Check if file exist
+    if not path.isfile('/proc/cpuinfo'):
+        return None
+
+    with open('/proc/cpuinfo', 'r') as f:
+        cpuinfo = f.read()
+
+    # Match a line like 'Revision   : a01041'
+    revision = search(r'^Revision\s+:\s+(\w+)$', cpuinfo,
+                      flags=MULTILINE | IGNORECASE)
+    if not revision:
+        # Couldn't find the hardware revision, assume it is not a Pi
+        return None
+
+    # Determine the Pi version using the processor bits using the new-style
+    # revision format
+    revision = int(revision.group(1), base=16)
+    if revision & 0x800000:
+        return ((revision & 0xF000) >> 12) + 1
+
+    # If it is not using the new style revision format,
+    # then it must be a Raspberry Pi 1
+    return 1
+
+
+pi_version = _get_pi_version()
diff --git a/kivy/vector.py b/kivy/vector.py
new file mode 100644
index 0000000..36b7c46
--- /dev/null
+++ b/kivy/vector.py
@@ -0,0 +1,412 @@
+'''Vector
+======
+
+The :class:`Vector` represents a 2D vector (x, y).
+Our implementation is built on top of a Python list.
+
+ An example of constructing a Vector::
+
+    >>> # Construct a point at 82,34
+    >>> v = Vector(82, 34)
+    >>> v[0]
+    82
+    >>> v.x
+    82
+    >>> v[1]
+    34
+    >>> v.y
+    34
+
+    >>> # Construct by giving a list of 2 values
+    >>> pos = (93, 45)
+    >>> v = Vector(pos)
+    >>> v[0]
+    93
+    >>> v.x
+    93
+    >>> v[1]
+    45
+    >>> v.y
+    45
+
+
+Optimized usage
+---------------
+
+Most of the time, you can use a list for arguments instead of using a
+Vector. For example, if you want to calculate the distance between 2
+points::
+
+    a = (10, 10)
+    b = (87, 34)
+
+    # optimized method
+    print('distance between a and b:', Vector(a).distance(b))
+
+    # non-optimized method
+    va = Vector(a)
+    vb = Vector(b)
+    print('distance between a and b:', va.distance(vb))
+
+
+Vector operators
+----------------
+
+The :class:`Vector` supports some numeric operators such as +, -, /::
+
+    >>> Vector(1, 1) + Vector(9, 5)
+    [10, 6]
+
+    >>> Vector(9, 5) - Vector(5, 5)
+    [4, 0]
+
+    >>> Vector(10, 10) / Vector(2., 4.)
+    [5.0, 2.5]
+
+    >>> Vector(10, 10) / 5.
+    [2.0, 2.0]
+
+
+You can also use in-place operators::
+
+    >>> v = Vector(1, 1)
+    >>> v += 2
+    >>> v
+    [3, 3]
+    >>> v *= 5
+    [15, 15]
+    >>> v /= 2.
+    [7.5, 7.5]
+
+'''
+
+__all__ = ('Vector', )
+
+import math
+
+
+class Vector(list):
+    '''Vector class. See module documentation for more information.
+    '''
+
+    def __init__(self, *largs):
+        if len(largs) == 1:
+            super(Vector, self).__init__(largs[0])
+        elif len(largs) == 2:
+            super(Vector, self).__init__(largs)
+        else:
+            raise Exception('Invalid vector')
+
+    def _get_x(self):
+        return self[0]
+
+    def _set_x(self, x):
+        self[0] = x
+
+    x = property(_get_x, _set_x)
+    ''':attr:`x` represents the first element in the list.
+
+    >>> v = Vector(12, 23)
+    >>> v[0]
+    12
+    >>> v.x
+    12
+    '''
+
+    def _get_y(self):
+        return self[1]
+
+    def _set_y(self, y):
+        self[1] = y
+
+    y = property(_get_y, _set_y)
+    ''':attr:`y` represents the second element in the list.
+
+    >>> v = Vector(12, 23)
+    >>> v[1]
+    23
+    >>> v.y
+    23
+
+    '''
+
+    def __getslice__(self, i, j):
+        try:
+            # use the list __getslice__ method and convert
+            # result to vector
+            return Vector(super(Vector, self).__getslice__(i, j))
+        except Exception:
+            raise TypeError('vector::FAILURE in __getslice__')
+
+    def __add__(self, val):
+        return Vector(list(map(lambda x, y: x + y, self, val)))
+
+    def __iadd__(self, val):
+        if type(val) in (int, float):
+            self.x += val
+            self.y += val
+        else:
+            self.x += val.x
+            self.y += val.y
+        return self
+
+    def __neg__(self):
+        return Vector([-x for x in self])
+
+    def __sub__(self, val):
+        return Vector(list(map(lambda x, y: x - y, self, val)))
+
+    def __isub__(self, val):
+        if type(val) in (int, float):
+            self.x -= val
+            self.y -= val
+        else:
+            self.x -= val.x
+            self.y -= val.y
+        return self
+
+    def __mul__(self, val):
+        try:
+            return Vector(list(map(lambda x, y: x * y, self, val)))
+        except Exception:
+            return Vector([x * val for x in self])
+
+    def __imul__(self, val):
+        if type(val) in (int, float):
+            self.x *= val
+            self.y *= val
+        else:
+            self.x *= val.x
+            self.y *= val.y
+        return self
+
+    def __rmul__(self, val):
+        return (self * val)
+
+    def __truediv__(self, val):
+        try:
+            return Vector(list(map(lambda x, y: x / y, self, val)))
+        except Exception:
+            return Vector([x / val for x in self])
+
+    def __div__(self, val):
+        try:
+            return Vector(list(map(lambda x, y: x / y, self, val)))
+        except Exception:
+            return Vector([x / val for x in self])
+
+    def __rtruediv__(self, val):
+        try:
+            return Vector(*val) / self
+        except Exception:
+            return Vector(val, val) / self
+
+    def __rdiv__(self, val):
+        try:
+            return Vector(*val) / self
+        except Exception:
+            return Vector(val, val) / self
+
+    def __idiv__(self, val):
+        if type(val) in (int, float):
+            self.x /= val
+            self.y /= val
+        else:
+            self.x /= val.x
+            self.y /= val.y
+        return self
+
+    def length(self):
+        '''Returns the length of a vector.
+
+        >>> Vector(10, 10).length()
+        14.142135623730951
+        >>> pos = (10, 10)
+        >>> Vector(pos).length()
+        14.142135623730951
+
+        '''
+        return math.sqrt(self[0] ** 2 + self[1] ** 2)
+
+    def length2(self):
+        '''Returns the length of a vector squared.
+
+        >>> Vector(10, 10).length2()
+        200
+        >>> pos = (10, 10)
+        >>> Vector(pos).length2()
+        200
+
+        '''
+        return self[0] ** 2 + self[1] ** 2
+
+    def distance(self, to):
+        '''Returns the distance between two points.
+
+        >>> Vector(10, 10).distance((5, 10))
+        5.
+        >>> a = (90, 33)
+        >>> b = (76, 34)
+        >>> Vector(a).distance(b)
+        14.035668847618199
+
+        '''
+        return math.sqrt((self[0] - to[0]) ** 2 + (self[1] - to[1]) ** 2)
+
+    def distance2(self, to):
+        '''Returns the distance between two points squared.
+
+        >>> Vector(10, 10).distance2((5, 10))
+        25
+
+        '''
+        return (self[0] - to[0]) ** 2 + (self[1] - to[1]) ** 2
+
+    def normalize(self):
+        '''Returns a new vector that has the same direction as vec,
+        but has a length of one.
+
+        >>> v = Vector(88, 33).normalize()
+        >>> v
+        [0.93632917756904444, 0.3511234415883917]
+        >>> v.length()
+        1.0
+
+        '''
+        if self[0] == 0. and self[1] == 0.:
+            return Vector(0., 0.)
+        return self / self.length()
+
+    def dot(self, a):
+        '''Computes the dot product of a and b.
+
+        >>> Vector(2, 4).dot((2, 2))
+        12
+
+        '''
+        return self[0] * a[0] + self[1] * a[1]
+
+    def angle(self, a):
+        '''Computes the angle between a and b, and returns the angle in
+        degrees.
+
+        >>> Vector(100, 0).angle((0, 100))
+        -90.0
+        >>> Vector(87, 23).angle((-77, 10))
+        -157.7920283010705
+
+        '''
+        angle = -(180 / math.pi) * math.atan2(
+            self[0] * a[1] - self[1] * a[0],
+            self[0] * a[0] + self[1] * a[1])
+        return angle
+
+    def rotate(self, angle):
+        '''Rotate the vector with an angle in degrees.
+
+        >>> v = Vector(100, 0)
+        >>> v.rotate(45)
+        [70.71067811865476, 70.71067811865474]
+
+        '''
+        angle = math.radians(angle)
+        return Vector(
+            (self[0] * math.cos(angle)) - (self[1] * math.sin(angle)),
+            (self[1] * math.cos(angle)) + (self[0] * math.sin(angle)))
+
+    @staticmethod
+    def line_intersection(v1, v2, v3, v4):
+        '''
+        Finds the intersection point between the lines (1)v1->v2 and (2)v3->v4
+        and returns it as a vector object.
+
+        >>> a = (98, 28)
+        >>> b = (72, 33)
+        >>> c = (10, -5)
+        >>> d = (20, 88)
+        >>> Vector.line_intersection(a, b, c, d)
+        [15.25931928687196, 43.911669367909241]
+
+        .. warning::
+
+            This is a line intersection method, not a segment intersection.
+
+        For math see: http://en.wikipedia.org/wiki/Line-line_intersection
+        '''
+        # linear algebar sucks...seriously!!
+        x1, x2, x3, x4 = float(v1[0]), float(v2[0]), float(v3[0]), float(v4[0])
+        y1, y2, y3, y4 = float(v1[1]), float(v2[1]), float(v3[1]), float(v4[1])
+
+        u = (x1 * y2 - y1 * x2)
+        v = (x3 * y4 - y3 * x4)
+        denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+        if denom == 0:
+            return None
+
+        px = (u * (x3 - x4) - (x1 - x2) * v) / denom
+        py = (u * (y3 - y4) - (y1 - y2) * v) / denom
+
+        return Vector(px, py)
+
+    @staticmethod
+    def segment_intersection(v1, v2, v3, v4):
+        '''
+        Finds the intersection point between segments (1)v1->v2 and (2)v3->v4
+        and returns it as a vector object.
+
+        >>> a = (98, 28)
+        >>> b = (72, 33)
+        >>> c = (10, -5)
+        >>> d = (20, 88)
+        >>> Vector.segment_intersection(a, b, c, d)
+        None
+
+        >>> a = (0, 0)
+        >>> b = (10, 10)
+        >>> c = (0, 10)
+        >>> d = (10, 0)
+        >>> Vector.segment_intersection(a, b, c, d)
+        [5, 5]
+        '''
+
+        # Yaaay! I love linear algebra applied within the realms of geometry.
+        x1, x2, x3, x4 = float(v1[0]), float(v2[0]), float(v3[0]), float(v4[0])
+        y1, y2, y3, y4 = float(v1[1]), float(v2[1]), float(v3[1]), float(v4[1])
+
+        # This is mostly the same as the line_intersection
+        u = (x1 * y2 - y1 * x2)
+        v = (x3 * y4 - y3 * x4)
+        denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+        if denom == 0:
+            return None
+
+        px = (u * (x3 - x4) - (x1 - x2) * v) / denom
+        py = (u * (y3 - y4) - (y1 - y2) * v) / denom
+        # Here are the new bits
+        c1 = (x1 <= px <= x2) or (x2 <= px <= x1) or (x1 == x2)
+        c2 = (y1 <= py <= y2) or (y2 <= py <= y1) or (y1 == y2)
+        c3 = (x3 <= px <= x4) or (x4 <= px <= x3) or (x3 == x4)
+        c4 = (y3 <= py <= y4) or (y4 <= py <= y3) or (y3 == y4)
+
+        if (c1 and c2) and (c3 and c4):
+            return Vector(px, py)
+        else:
+            return None
+
+    @staticmethod
+    def in_bbox(point, a, b):
+        '''Return True if `point` is in the bounding box defined by `a`
+        and `b`.
+
+        >>> bmin = (0, 0)
+        >>> bmax = (100, 100)
+        >>> Vector.in_bbox((50, 50), bmin, bmax)
+        True
+        >>> Vector.in_bbox((647, -10), bmin, bmax)
+        False
+
+        '''
+        return ((point[0] <= a[0] and point[0] >= b[0] or
+                 point[0] <= b[0] and point[0] >= a[0]) and
+                (point[1] <= a[1] and point[1] >= b[1] or
+                 point[1] <= b[1] and point[1] >= a[1]))
diff --git a/kivy/weakmethod.py b/kivy/weakmethod.py
new file mode 100644
index 0000000..aa676ee
--- /dev/null
+++ b/kivy/weakmethod.py
@@ -0,0 +1,72 @@
+"""
+Weak Method
+===========
+
+The :class:`WeakMethod` is used by the :class:`~kivy.clock.Clock` class to
+allow references to a bound method that permits the associated object to
+be garbage collected. Please refer to
+`examples/core/clock_method.py` for more information.
+
+This WeakMethod class is taken from the recipe
+http://code.activestate.com/recipes/81253/, based on the nicodemus version.
+Many thanks nicodemus!
+"""
+
+import weakref
+
+
+class WeakMethod:
+    '''Implementation of a
+    `weakref <http://en.wikipedia.org/wiki/Weak_reference>`_
+    for functions and bound methods.
+    '''
+    def __init__(self, method):
+        self.method = None
+        self.method_name = None
+        try:
+            if method.__self__ is not None:
+                self.method_name = method.__func__.__name__
+                self.proxy = weakref.proxy(method.__self__)
+            else:
+                self.method = method
+                self.proxy = None
+        except AttributeError:
+            self.method = method
+            self.proxy = None
+
+    def __call__(self):
+        '''Return a new bound-method like the original, or the
+        original function if it was just a function or unbound
+        method.
+        Returns None if the original object doesn't exist.
+        '''
+        if self.proxy is not None:
+            try:
+                return getattr(self.proxy, self.method_name)
+            except ReferenceError:
+                return None
+
+        return self.method
+
+    def is_dead(self):
+        '''Returns True if the referenced callable was a bound method and
+        the instance no longer exists. Otherwise, return False.
+        '''
+        if self.proxy is None:
+            return False
+
+        try:
+            getattr(self.proxy, self.method_name)
+            return False
+        except ReferenceError:
+            return True
+
+    def __eq__(self, other):
+        if type(self) is not type(other):
+            return False
+        s = self()
+        return s is not None and s == other()
+
+    def __repr__(self):
+        return '<WeakMethod proxy={} method={} method_name={}>'.format(
+               self.proxy, self.method, self.method_name)
diff --git a/kivy/weakproxy.cpython-310-x86_64-linux-gnu.so b/kivy/weakproxy.cpython-310-x86_64-linux-gnu.so
new file mode 100755
index 0000000..5da22f5
Binary files /dev/null and b/kivy/weakproxy.cpython-310-x86_64-linux-gnu.so differ