Skip to content

Instantly share code, notes, and snippets.

@matham

matham/style.kvc

Created May 27, 2015 21:08
Show Gist options
  • Save matham/f7ce6e32ecf5c75c4e68 to your computer and use it in GitHub Desktop.
Save matham/f7ce6e32ecf5c75c4e68 to your computer and use it in GitHub Desktop.
Download ZIP
compiler
Raw
style.kvc
# -*- coding: utf-8 -*-
# Compiled from G:\Python\dev2\kivy\kivy\data\style.kv at 2015-05-27 01:56:28.807000
__version__ = "1.9.1-dev"
__source_file__ = r"G:\Python\dev2\kivy\kivy\data\style.kv"
__source_hash__ = b"30344218c5162f5a94729242fbdf35fe1b86f4376d47c9cef55455e97ee2c3cc"
import kivy.metrics as Metrics
from kivy.factory import Factory
from kivy.lang import (
Builder, ParserSelectorName, _handlers, ProxyApp, delayed_call_fn)
from kivy import require
from functools import partial
from kivy.event import EventDispatcher, Observable
app = ProxyApp()
pt = Metrics.pt
inch = Metrics.inch
cm = Metrics.cm
mm = Metrics.mm
dp = Metrics.dp
sp = Metrics.sp
_mc = [None, ] * 70
def rebind_callback(bound, i, instance, value):
# bound[i] and p cannot be None b/c it dispatched
s, e, pidx, p, key, _, _, _ = bound[i]
# we need to rebind all children of root (p.key). First check if the value
# actually changed - i.e. whether p.key is the same as `value`. p.key is
# the parent of p.key.x and is stored as the parent of the first child of
# p.key, so find the first child of p.key (p.key.x) and use its 1st child
# `s` is the first direct child of p.key (s, e) are all the (indirect)
# children
try:
if value == bound[s][3]:
return
except ReferenceError:
pass
# now, everything must have a non-None parent idx since p.key is the root
# also, since p.key was rebind, every node below it will have bound[node]
# not be None, even if it was not bound in case it would have rebind
# now unbind all the children, and along the way set each parent value
# to be the new parent in the p.key.x.y.z... tree. cache the values here.
# keys are the index of the parent
parent = {}
p = getattr(p, key) # next parent
if p is None or not isinstance(object, ('EventDispatcher', 'Observable')):
parent[i] = p, None, None, None, None
else:
parent[i] = p, p.proxy_ref, p.fast_bind, p.property, p.rebind_property
dispatch = [None, ] * (e - s)
for k, node in enumerate(range(s, e)):
node_s, node_e, pidx, p, key, bid, f, args = blist = bound[i]
# node_s/e being None means it's a leaf with no children
if bid: # unbind parent's rebind
try:
p.unbind_uid(key, bid)
except ReferenceError:
pass
p, pref, bind, prop_get, rebind_prop = parent[pidx]
# decide whether we can bind to this object
if bind is not None and node_s is None: # a leaf
blist[3] = pref
uid = blist[5] = bind(key, f, *args)
if uid: # it is a kivy prop
prop = prop_get(key)
dispatch[k] = (
node, p, prop.dispatch_stale, prop.dispatch_count(p))
continue
elif bind is not None and rebind_prop(key): # a rebind node
blist[3] = pref
blist[5] = bind(key, f, *args)
if uid: # it is a kivy prop
prop = prop_get(key)
dispatch[k] = (
node, p, prop.dispatch_stale, prop.dispatch_count(p))
else: # either no obj, or obj but no rebind and it's not a leaf
blist[3] = blist[5] = None
if node_s is None:
continue
# if the key is a leaf, don't save the key as a parent b/c it has no
# children, hence the continue above
if node not in parent:
if p is None: # our parent is already None
parent[node] = (None, None, None, None, None)
else:
p = getattr(p, key) # next parent
if p is None or not isinstance(object, (EventDispatcher, )):
parent[node] = p, None, None, None, None
else:
parent[node] = (
p, p.proxy_ref, p.fast_bind, p.property,
p.rebind_property)
for item in dispatch:
if item is None:
continue
i, p, dispatch_stale, count = item
try:
if p == bound[i][3]:
dispatch_stale(p, count)
except ReferenceError:
pass
# directives
require("1.0")
def rgba_h0(g1, root, *args):
root = root.__self__
g1.rgba = root.disabled_color if root.disabled else (root.color if not root.markup else (1, 1, 1, 1))
def texture_h1(g2, root, *args):
g2.texture = root.texture
def size_h2(g2, root, *args):
g2.size = root.texture_size
def pos_h3(g2, root, *args):
root = root.__self__
g2.pos = int(root.center_x - root.texture_size[0] / 2.), int(root.center_y - root.texture_size[1] / 2.)
# <Label> L2
def _r0(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.Rectangle()
root_canvas_root_add(g2)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b0(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b0, app, g1, g2, root))
def _b0(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h0 = [rgba_h0, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h0, None, None)
delayed_texture_h1 = [texture_h1, g2_ref, root_ref, None]
delayed_call_fn(delayed_texture_h1, None, None)
delayed_size_h2 = [size_h2, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h2, None, None)
delayed_pos_h3 = [pos_h3, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h3, None, None)
root_bound = bound = [None, ] * 9
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_rgba_h0), delayed_call_fn, (delayed_rgba_h0, )]
bound[1] = [None, None, None, root_ref, "color", bind("color", delayed_call_fn, delayed_rgba_h0), delayed_call_fn, (delayed_rgba_h0, )]
bound[2] = [None, None, None, root_ref, "markup", bind("markup", delayed_call_fn, delayed_rgba_h0), delayed_call_fn, (delayed_rgba_h0, )]
bound[3] = [None, None, None, root_ref, "disabled_color", bind("disabled_color", delayed_call_fn, delayed_rgba_h0), delayed_call_fn, (delayed_rgba_h0, )]
bound[4] = [None, None, None, root_ref, "texture", bind("texture", delayed_call_fn, delayed_texture_h1), delayed_call_fn, (delayed_texture_h1, )]
bound[5] = [None, None, None, root_ref, "texture_size", bind("texture_size", delayed_call_fn, delayed_size_h2), delayed_call_fn, (delayed_size_h2, )]
bound[6] = [None, None, None, root_ref, "texture_size", bind("texture_size", delayed_call_fn, delayed_pos_h3), delayed_call_fn, (delayed_pos_h3, )]
bound[7] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h3), delayed_call_fn, (delayed_pos_h3, )]
bound[8] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h3), delayed_call_fn, (delayed_pos_h3, )]
_handlers[g2.uid].append((bound, (4, 5, 6, 7, 8)))
_handlers[g1.uid].append((bound, (0, 1, 2, 3)))
return tuple
def state_image_h4(root, *args):
root = root.__self__
root.state_image = root.background_normal if root.state == 'normal' else root.background_down
def disabled_image_h5(root, *args):
root = root.__self__
root.disabled_image = root.background_disabled_normal if root.state == 'normal' else root.background_disabled_down
def rgba_h6(g1, root, *args):
g1.rgba = root.background_color
def border_h7(g2, root, *args):
g2.border = root.border
def pos_h8(g2, root, *args):
g2.pos = root.pos
def size_h9(g2, root, *args):
g2.size = root.size
def source_h10(g2, root, *args):
root = root.__self__
g2.source = root.disabled_image if root.disabled else root.state_image
def rgba_h11(g3, root, *args):
root = root.__self__
g3.rgba = root.disabled_color if root.disabled else root.color
def texture_h12(g4, root, *args):
g4.texture = root.texture
def size_h13(g4, root, *args):
g4.size = root.texture_size
def pos_h14(g4, root, *args):
root = root.__self__
g4.pos = int(root.center_x - root.texture_size[0] / 2.), int(root.center_y - root.texture_size[1] / 2.)
# <-Button,-ToggleButton> L11
_mc[1] = set()
def _r1(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Color = Factory.Color
root_canvas_root_add = root.canvas.add
g1 = cls_Color()
root_canvas_root_add(g1)
g2 = Factory.BorderImage()
root_canvas_root_add(g2)
g3 = cls_Color()
root_canvas_root_add(g3)
g4 = Factory.Rectangle()
root_canvas_root_add(g4)
if root.__class__ not in _mc[1]:
root_create_property = root.create_property
if not hasattr(root, "state_image"):
root_create_property("state_image", (None))
if not hasattr(root, "disabled_image"):
root_create_property("disabled_image", (None))
_mc[1].add(root.__class__)
root.state_image = root.background_normal if root.state == 'normal' else root.background_down
root.disabled_image = root.background_disabled_normal if root.state == 'normal' else root.background_disabled_down
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b1(app, g1, g2, g3, g4, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b1, app, g1, g2, g3, g4, root))
def _b1(app, g1, g2, g3, g4, root):
g2_ref = g2.proxy_ref
g4_ref = g4.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h6 = [rgba_h6, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h6, None, None)
delayed_border_h7 = [border_h7, g2_ref, root_ref, None]
delayed_call_fn(delayed_border_h7, None, None)
delayed_pos_h8 = [pos_h8, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h8, None, None)
delayed_size_h9 = [size_h9, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h9, None, None)
delayed_source_h10 = [source_h10, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h10, None, None)
delayed_rgba_h11 = [rgba_h11, g3.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h11, None, None)
delayed_texture_h12 = [texture_h12, g4_ref, root_ref, None]
delayed_call_fn(delayed_texture_h12, None, None)
delayed_size_h13 = [size_h13, g4_ref, root_ref, None]
delayed_call_fn(delayed_size_h13, None, None)
delayed_pos_h14 = [pos_h14, g4_ref, root_ref, None]
delayed_call_fn(delayed_pos_h14, None, None)
root_bound = bound = [None, ] * 21
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "background_normal", bind("background_normal", state_image_h4, root_ref), state_image_h4, (root_ref, )]
bound[1] = [None, None, None, root_ref, "state", bind("state", state_image_h4, root_ref), state_image_h4, (root_ref, )]
bound[2] = [None, None, None, root_ref, "background_down", bind("background_down", state_image_h4, root_ref), state_image_h4, (root_ref, )]
bound[3] = [None, None, None, root_ref, "background_disabled_normal", bind("background_disabled_normal", disabled_image_h5, root_ref), disabled_image_h5, (root_ref, )]
bound[4] = [None, None, None, root_ref, "state", bind("state", disabled_image_h5, root_ref), disabled_image_h5, (root_ref, )]
bound[5] = [None, None, None, root_ref, "background_disabled_down", bind("background_disabled_down", disabled_image_h5, root_ref), disabled_image_h5, (root_ref, )]
bound[6] = [None, None, None, root_ref, "background_color", bind("background_color", delayed_call_fn, delayed_rgba_h6), delayed_call_fn, (delayed_rgba_h6, )]
bound[7] = [None, None, None, root_ref, "border", bind("border", delayed_call_fn, delayed_border_h7), delayed_call_fn, (delayed_border_h7, )]
bound[8] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h8), delayed_call_fn, (delayed_pos_h8, )]
bound[9] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h9), delayed_call_fn, (delayed_size_h9, )]
bound[10] = [None, None, None, root_ref, "disabled_image", bind("disabled_image", delayed_call_fn, delayed_source_h10), delayed_call_fn, (delayed_source_h10, )]
bound[11] = [None, None, None, root_ref, "state_image", bind("state_image", delayed_call_fn, delayed_source_h10), delayed_call_fn, (delayed_source_h10, )]
bound[12] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_source_h10), delayed_call_fn, (delayed_source_h10, )]
bound[13] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_rgba_h11), delayed_call_fn, (delayed_rgba_h11, )]
bound[14] = [None, None, None, root_ref, "color", bind("color", delayed_call_fn, delayed_rgba_h11), delayed_call_fn, (delayed_rgba_h11, )]
bound[15] = [None, None, None, root_ref, "disabled_color", bind("disabled_color", delayed_call_fn, delayed_rgba_h11), delayed_call_fn, (delayed_rgba_h11, )]
bound[16] = [None, None, None, root_ref, "texture", bind("texture", delayed_call_fn, delayed_texture_h12), delayed_call_fn, (delayed_texture_h12, )]
bound[17] = [None, None, None, root_ref, "texture_size", bind("texture_size", delayed_call_fn, delayed_size_h13), delayed_call_fn, (delayed_size_h13, )]
bound[18] = [None, None, None, root_ref, "texture_size", bind("texture_size", delayed_call_fn, delayed_pos_h14), delayed_call_fn, (delayed_pos_h14, )]
bound[19] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h14), delayed_call_fn, (delayed_pos_h14, )]
bound[20] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h14), delayed_call_fn, (delayed_pos_h14, )]
_handlers[g3.uid].append((bound, (13, 14, 15)))
_handlers[g4.uid].append((bound, (16, 17, 18, 19, 20)))
_handlers[root.uid].append((bound, (0, 1, 2, 3, 4, 5)))
_handlers[g2.uid].append((bound, (7, 8, 9, 10, 11, 12)))
_handlers[g1.uid].append((bound, (6, )))
return tuple
def opacity_h15(root, *args):
root.opacity = .7 if root.disabled else 1
def rgba_h16(g1, root, *args):
root = root.__self__
g1.rgba = root.parent.background_color if root.parent else (1, 1, 1, 1)
def border_h17(g2, root, *args):
root = root.__self__
g2.border = root.parent.border if root.parent else (16, 16, 16, 16)
def texture_h18(g2, root, *args):
root = root.__self__
g2.texture = root.parent._bk_img.texture if root.parent else None
def size_h19(g2, root, *args):
g2.size = root.size
def pos_h20(g2, root, *args):
g2.pos = root.pos
# <BubbleContent> L29
_mc[2] = set()
def _r2(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.BorderImage()
root_canvas_root_add(g2)
if root.__class__ not in _mc[2]:
root_create_property = root.create_property
if not hasattr(root, "opacity"):
root_create_property("opacity", (None))
if not hasattr(root, "rows"):
root_create_property("rows", (1))
_mc[2].add(root.__class__)
root.rows = 1
root.opacity = .7 if root.disabled else 1
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b2(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b2, app, g1, g2, root))
def _b2(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h16 = [rgba_h16, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h16, None, None)
delayed_border_h17 = [border_h17, g2_ref, root_ref, None]
delayed_call_fn(delayed_border_h17, None, None)
delayed_texture_h18 = [texture_h18, g2_ref, root_ref, None]
delayed_call_fn(delayed_texture_h18, None, None)
delayed_size_h19 = [size_h19, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h19, None, None)
delayed_pos_h20 = [pos_h20, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h20, None, None)
dispatch_objs = [None, ] * 2
root_bound = bound = [None, ] * 11
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "disabled", bind("disabled", opacity_h15, root_ref), opacity_h15, (root_ref, )]
bound[1] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_rgba_h16), delayed_call_fn, (delayed_rgba_h16, )]
bound[2] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_border_h17), delayed_call_fn, (delayed_border_h17, )]
bound[3] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_texture_h18), delayed_call_fn, (delayed_texture_h18, )]
bound[4] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h19), delayed_call_fn, (delayed_size_h19, )]
bound[5] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h20), delayed_call_fn, (delayed_pos_h20, )]
if root.rebind_property("parent"):
bound[6] = [7, 11, None, root_ref, "parent", bind("parent", rebind_callback, bound, 6), rebind_callback, (bound, 6)]
if bound[6][5]:
prop = root.property("parent")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
else:
bound[6] = [7, 11, None, None, "parent", None, rebind_callback, (bound, 6)]
obj_root_parent = root.parent
if obj_root_parent is not None and isinstance(obj_root_parent, (EventDispatcher, Observable)):
obj_root_parent_ref = obj_root_parent.proxy_ref
bind = obj_root_parent.fast_bind
bound[7] = [None, None, 6, obj_root_parent_ref, "background_color", bind("background_color", delayed_call_fn, delayed_rgba_h16), delayed_call_fn, (delayed_rgba_h16, )]
bound[8] = [None, None, 6, obj_root_parent_ref, "border", bind("border", delayed_call_fn, delayed_border_h17), delayed_call_fn, (delayed_border_h17, )]
if obj_root_parent.rebind_property("_bk_img"):
bound[9] = [10, 11, 6, obj_root_parent_ref, "_bk_img", bind("_bk_img", rebind_callback, bound, 9), rebind_callback, (bound, 9)]
if bound[9][5]:
prop = obj_root_parent.property("_bk_img")
dispatch_objs[1] = [obj_root_parent, prop, prop.dispatch_count(obj_root_parent)]
else:
bound[9] = [10, 11, 6, None, "_bk_img", None, rebind_callback, (bound, 9)]
if bound[6] is not None and bound[7] is None:
bound[7] = [None, None, 6, None, "background_color", None, delayed_call_fn, (delayed_rgba_h16, )]
bound[8] = [None, None, 6, None, "border", None, delayed_call_fn, (delayed_border_h17, )]
bound[9] = [10, 11, 6, None, "_bk_img", None, rebind_callback, (bound, 9)]
if obj_root_parent is not None:
obj_root_parent__bk_img = obj_root_parent._bk_img
if obj_root_parent__bk_img is not None and isinstance(obj_root_parent__bk_img, (EventDispatcher, Observable)):
bind = obj_root_parent__bk_img.fast_bind
bound[10] = [None, None, 9, obj_root_parent__bk_img.proxy_ref, "texture", bind("texture", delayed_call_fn, delayed_texture_h18), delayed_call_fn, (delayed_texture_h18, )]
if bound[9] is not None and bound[10] is None:
bound[10] = [None, None, 9, None, "texture", None, delayed_call_fn, (delayed_texture_h18, )]
_handlers[root.uid].append((bound, (0, )))
_handlers[g2.uid].append((bound, (2, 3, 4, 5, 8, 10)))
_handlers[g1.uid].append((bound, (1, 7)))
return partial(_d2, root_bound, dispatch_objs, ())
def _d2(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
try:
if obj == root_bound[9][3]:
prop.dispatch_stale(obj, count)
except ReferenceError:
pass
return widgets
# <BubbleButton> L41
_mc[3] = set()
def _r3(root, builder_created):
if root.__class__ not in _mc[3]:
root_create_property = root.create_property
if not hasattr(root, "background_normal"):
root_create_property("background_normal", ('atlas://data/images/defaulttheme/bubble_btn'))
if not hasattr(root, "background_down"):
root_create_property("background_down", ('atlas://data/images/defaulttheme/bubble_btn_pressed'))
if not hasattr(root, "background_disabled_normal"):
root_create_property("background_disabled_normal", ('atlas://data/images/defaulttheme/bubble_btn'))
if not hasattr(root, "background_disabled_down"):
root_create_property("background_disabled_down", ('atlas://data/images/defaulttheme/bubble_btn_pressed'))
if not hasattr(root, "border"):
root_create_property("border", ((0, 0, 0, 0)))
_mc[3].add(root.__class__)
root.background_normal = 'atlas://data/images/defaulttheme/bubble_btn'
root.background_down = 'atlas://data/images/defaulttheme/bubble_btn_pressed'
root.background_disabled_normal = 'atlas://data/images/defaulttheme/bubble_btn'
root.background_disabled_down = 'atlas://data/images/defaulttheme/bubble_btn_pressed'
root.border = (0, 0, 0, 0)
def border_h21(g2, root, *args):
g2.border = (0, 18, 0, 18) if root.orientation == 'horizontal' else (18, 0, 18, 0)
def pos_h22(g2, root, *args):
root = root.__self__
g2.pos = (root.x + root.padding, root.center_y - sp(18)) if root.orientation == 'horizontal' else (root.center_x - 18, root.y + root.padding)
def size_h23(g2, root, *args):
root = root.__self__
g2.size = (root.width - root.padding * 2, sp(36)) if root.orientation == 'horizontal' else (sp(36), root.height - root.padding * 2)
def source_h24(g2, root, *args):
root = root.__self__
g2.source = 'atlas://data/images/defaulttheme/slider{}_background{}'.format(root.orientation[0], '_disabled' if root.disabled else '')
def pos_h25(g3, root, *args):
root = root.__self__
g3.pos = (root.value_pos[0] - sp(16), root.center_y - sp(17)) if root.orientation == 'horizontal' else (root.center_x - (16), root.value_pos[1] - sp(16))
def source_h26(g3, root, *args):
g3.source = 'atlas://data/images/defaulttheme/slider_cursor{}'.format('_disabled' if root.disabled else '')
# <Slider> L48
def _r4(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.BorderImage()
root_canvas_root_add(g2)
g3 = Factory.Rectangle()
root_canvas_root_add(g3)
g1.rgb = 1, 1, 1
g3.size = (sp(32), sp(32))
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b4(app, g1, g2, g3, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b4, app, g1, g2, g3, root))
def _b4(app, g1, g2, g3, root):
g2_ref = g2.proxy_ref
g3_ref = g3.proxy_ref
root_ref = root.proxy_ref
delayed_border_h21 = [border_h21, g2_ref, root_ref, None]
delayed_call_fn(delayed_border_h21, None, None)
delayed_pos_h22 = [pos_h22, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h22, None, None)
delayed_size_h23 = [size_h23, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h23, None, None)
delayed_source_h24 = [source_h24, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h24, None, None)
delayed_pos_h25 = [pos_h25, g3_ref, root_ref, None]
delayed_call_fn(delayed_pos_h25, None, None)
delayed_source_h26 = [source_h26, g3_ref, root_ref, None]
delayed_call_fn(delayed_source_h26, None, None)
root_bound = bound = [None, ] * 18
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "orientation", bind("orientation", delayed_call_fn, delayed_border_h21), delayed_call_fn, (delayed_border_h21, )]
bound[1] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h22), delayed_call_fn, (delayed_pos_h22, )]
bound[2] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h22), delayed_call_fn, (delayed_pos_h22, )]
bound[3] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h22), delayed_call_fn, (delayed_pos_h22, )]
bound[4] = [None, None, None, root_ref, "padding", bind("padding", delayed_call_fn, delayed_pos_h22), delayed_call_fn, (delayed_pos_h22, )]
bound[5] = [None, None, None, root_ref, "orientation", bind("orientation", delayed_call_fn, delayed_pos_h22), delayed_call_fn, (delayed_pos_h22, )]
bound[6] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h22), delayed_call_fn, (delayed_pos_h22, )]
bound[7] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h23), delayed_call_fn, (delayed_size_h23, )]
bound[8] = [None, None, None, root_ref, "orientation", bind("orientation", delayed_call_fn, delayed_size_h23), delayed_call_fn, (delayed_size_h23, )]
bound[9] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_size_h23), delayed_call_fn, (delayed_size_h23, )]
bound[10] = [None, None, None, root_ref, "padding", bind("padding", delayed_call_fn, delayed_size_h23), delayed_call_fn, (delayed_size_h23, )]
bound[11] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_source_h24), delayed_call_fn, (delayed_source_h24, )]
bound[12] = [None, None, None, root_ref, "orientation", bind("orientation", delayed_call_fn, delayed_source_h24), delayed_call_fn, (delayed_source_h24, )]
bound[13] = [None, None, None, root_ref, "orientation", bind("orientation", delayed_call_fn, delayed_pos_h25), delayed_call_fn, (delayed_pos_h25, )]
bound[14] = [None, None, None, root_ref, "value_pos", bind("value_pos", delayed_call_fn, delayed_pos_h25), delayed_call_fn, (delayed_pos_h25, )]
bound[15] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h25), delayed_call_fn, (delayed_pos_h25, )]
bound[16] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h25), delayed_call_fn, (delayed_pos_h25, )]
bound[17] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_source_h26), delayed_call_fn, (delayed_source_h26, )]
_handlers[g3.uid].append((bound, (13, 14, 15, 16, 17)))
_handlers[g2.uid].append((bound, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)))
return tuple
def pos_h27(g2, root, *args):
root = root.__self__
g2.pos = root.x, root.center_y - 12
def size_h28(g2, root, *args):
g2.size = root.width, 24
def border_h29(g3, root, *args):
root = root.__self__
g3.border = [int(min(root.width * (root.value / float(root.max)) if root.max else 0, 12))] * 4
def pos_h30(g3, root, *args):
root = root.__self__
g3.pos = root.x, root.center_y - 12
def size_h31(g3, root, *args):
root = root.__self__
g3.size = root.width * (root.value / float(root.max)) if root.max else 0, 24
# <ProgressBar> L62
def _r5(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_BorderImage = Factory.BorderImage
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = cls_BorderImage()
root_canvas_root_add(g2)
g3 = cls_BorderImage()
root_canvas_root_add(g3)
g1.rgb = 1, 1, 1
g2.border = (12, 12, 12, 12)
g2.source = 'atlas://data/images/defaulttheme/progressbar_background'
g3.source = 'atlas://data/images/defaulttheme/progressbar'
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b5(app, g1, g2, g3, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b5, app, g1, g2, g3, root))
def _b5(app, g1, g2, g3, root):
g2_ref = g2.proxy_ref
g3_ref = g3.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h27 = [pos_h27, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h27, None, None)
delayed_size_h28 = [size_h28, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h28, None, None)
delayed_border_h29 = [border_h29, g3_ref, root_ref, None]
delayed_call_fn(delayed_border_h29, None, None)
delayed_pos_h30 = [pos_h30, g3_ref, root_ref, None]
delayed_call_fn(delayed_pos_h30, None, None)
delayed_size_h31 = [size_h31, g3_ref, root_ref, None]
delayed_call_fn(delayed_size_h31, None, None)
root_bound = bound = [None, ] * 11
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h27), delayed_call_fn, (delayed_pos_h27, )]
bound[1] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h27), delayed_call_fn, (delayed_pos_h27, )]
bound[2] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h28), delayed_call_fn, (delayed_size_h28, )]
bound[3] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_border_h29), delayed_call_fn, (delayed_border_h29, )]
bound[4] = [None, None, None, root_ref, "value", bind("value", delayed_call_fn, delayed_border_h29), delayed_call_fn, (delayed_border_h29, )]
bound[5] = [None, None, None, root_ref, "max", bind("max", delayed_call_fn, delayed_border_h29), delayed_call_fn, (delayed_border_h29, )]
bound[6] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h30), delayed_call_fn, (delayed_pos_h30, )]
bound[7] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h30), delayed_call_fn, (delayed_pos_h30, )]
bound[8] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h31), delayed_call_fn, (delayed_size_h31, )]
bound[9] = [None, None, None, root_ref, "value", bind("value", delayed_call_fn, delayed_size_h31), delayed_call_fn, (delayed_size_h31, )]
bound[10] = [None, None, None, root_ref, "max", bind("max", delayed_call_fn, delayed_size_h31), delayed_call_fn, (delayed_size_h31, )]
_handlers[g3.uid].append((bound, (3, 4, 5, 6, 7, 8, 9, 10)))
_handlers[g2.uid].append((bound, (0, 1, 2)))
return tuple
def border_h32(root, *args):
root = root.__self__
root.border = root.parent.border if root.parent else (3, 3, 3, 3)
def horizontal_h33(root, *args):
root = root.__self__
root.horizontal = '_h' if root.parent and root.parent.sizable_from[0] in ('t', 'b') else ''
def background_normal_h34(root, *args):
root = root.__self__
root.background_normal = 'atlas://data/images/defaulttheme/splitter{}{}'.format('_disabled' if root.disabled else '', root.horizontal)
def background_down_h35(root, *args):
root = root.__self__
root.background_down = 'atlas://data/images/defaulttheme/splitter_down{}{}'.format('_disabled' if root.disabled else '', root.horizontal)
def pos_h36(root, w1, *args):
w1.pos = root.pos
def size_h37(root, w1, *args):
w1.size = root.size
def source_h38(root, w1, *args):
w1.source = 'atlas://data/images/defaulttheme/splitter_grip' + root.horizontal
# <SplitterStrip> L77
_mc[6] = set()
def _r6(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.Image(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[6]:
root_create_property = root.create_property
if not hasattr(root, "border"):
root_create_property("border", (None))
if not hasattr(root, "horizontal"):
root_create_property("horizontal", (None))
if not hasattr(root, "background_normal"):
root_create_property("background_normal", (None))
if not hasattr(root, "background_down"):
root_create_property("background_down", (None))
w1_create_property = w1.create_property
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "size"):
w1_create_property("size", (None))
if not hasattr(w1, "allow_stretch"):
w1_create_property("allow_stretch", (None))
if not hasattr(w1, "source"):
w1_create_property("source", (None))
_mc[6].add(root.__class__)
w1.allow_stretch = True
root.border = root.parent.border if root.parent else (3, 3, 3, 3)
root.horizontal = '_h' if root.parent and root.parent.sizable_from[0] in ('t', 'b') else ''
root.background_normal = 'atlas://data/images/defaulttheme/splitter{}{}'.format('_disabled' if root.disabled else '', root.horizontal)
root.background_down = 'atlas://data/images/defaulttheme/splitter_down{}{}'.format('_disabled' if root.disabled else '', root.horizontal)
w1.pos = root.pos
w1.size = root.size
w1.source = 'atlas://data/images/defaulttheme/splitter_grip' + root.horizontal
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b6(app, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b6, app, root, w1))
def _b6(app, root, w1):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
dispatch_objs = [None, ] * 4
root_bound = bound = [None, ] * 12
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "parent", bind("parent", border_h32, root_ref), border_h32, (root_ref, )]
bound[1] = [None, None, None, root_ref, "parent", bind("parent", horizontal_h33, root_ref), horizontal_h33, (root_ref, )]
if bound[1][5]:
prop = root_get_prop("parent")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "disabled", bind("disabled", background_normal_h34, root_ref), background_normal_h34, (root_ref, )]
bound[3] = [None, None, None, root_ref, "horizontal", bind("horizontal", background_normal_h34, root_ref), background_normal_h34, (root_ref, )]
bound[4] = [None, None, None, root_ref, "disabled", bind("disabled", background_down_h35, root_ref), background_down_h35, (root_ref, )]
bound[5] = [None, None, None, root_ref, "horizontal", bind("horizontal", background_down_h35, root_ref), background_down_h35, (root_ref, )]
bound[6] = [None, None, None, root_ref, "pos", bind("pos", pos_h36, root_ref, w1_ref), pos_h36, [root_ref, w1_ref]]
if bound[6][5]:
prop = root_get_prop("pos")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[7] = [None, None, None, root_ref, "size", bind("size", size_h37, root_ref, w1_ref), size_h37, [root_ref, w1_ref]]
if bound[7][5]:
prop = root_get_prop("size")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[8] = [None, None, None, root_ref, "horizontal", bind("horizontal", source_h38, root_ref, w1_ref), source_h38, [root_ref, w1_ref]]
if root.rebind_property("parent"):
bound[9] = [10, 12, None, root_ref, "parent", bind("parent", rebind_callback, bound, 9), rebind_callback, (bound, 9)]
else:
bound[9] = [10, 12, None, None, "parent", None, rebind_callback, (bound, 9)]
obj_root_parent = root.parent
if obj_root_parent is not None and isinstance(obj_root_parent, (EventDispatcher, Observable)):
obj_root_parent_ref = obj_root_parent.proxy_ref
bind = obj_root_parent.fast_bind
bound[10] = [None, None, 9, obj_root_parent_ref, "border", bind("border", border_h32, root_ref), border_h32, (root_ref, )]
if bound[10][5]:
prop = obj_root_parent.property("border")
dispatch_objs[3] = [obj_root_parent, prop, prop.dispatch_count(obj_root_parent)]
bound[11] = [None, None, 9, obj_root_parent_ref, "sizable_from", bind("sizable_from", horizontal_h33, root_ref), horizontal_h33, (root_ref, )]
if bound[9] is not None and bound[10] is None:
bound[10] = [None, None, 9, None, "border", None, border_h32, (root_ref, )]
bound[11] = [None, None, 9, None, "sizable_from", None, horizontal_h33, (root_ref, )]
_handlers[root.uid].append((bound, (0, 1, 2, 3, 4, 5, 10, 11)))
_handlers[w1.uid].append((bound, (6, 7, 8)))
return partial(_d6, root_bound, dispatch_objs, (w1, ))
def _d6(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
try:
if obj == root_bound[10][3]:
prop.dispatch_stale(obj, count)
except ReferenceError:
pass
return widgets
def matrix_h39(g2, root, *args):
g2.matrix = root.transform
# <Scatter> L88
def _r7(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_before_add = root.canvas.before.add
g1 = Factory.PushMatrix()
root_canvas_before_add(g1)
g2 = Factory.MatrixInstruction()
root_canvas_before_add(g2)
g3 = Factory.PopMatrix()
root.canvas.after.add(g3)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b7(app, g1, g2, g3, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b7, app, g1, g2, g3, root))
def _b7(app, g1, g2, g3, root):
root_ref = root.proxy_ref
delayed_matrix_h39 = [matrix_h39, g2.proxy_ref, root_ref, None]
delayed_call_fn(delayed_matrix_h39, None, None)
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "transform", root.fast_bind("transform", delayed_call_fn, delayed_matrix_h39), delayed_call_fn, (delayed_matrix_h39, )]
_handlers[g2.uid].append((bound, (0, )))
return tuple
def xy_h40(g2, root, *args):
g2.xy = root.pos
# <RelativeLayout> L97
def _r8(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_before_add = root.canvas.before.add
g1 = Factory.PushMatrix()
root_canvas_before_add(g1)
g2 = Factory.Translate()
root_canvas_before_add(g2)
g3 = Factory.PopMatrix()
root.canvas.after.add(g3)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b8(app, g1, g2, g3, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b8, app, g1, g2, g3, root))
def _b8(app, g1, g2, g3, root):
root_ref = root.proxy_ref
delayed_xy_h40 = [xy_h40, g2.proxy_ref, root_ref, None]
delayed_call_fn(delayed_xy_h40, None, None)
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "pos", root.fast_bind("pos", delayed_call_fn, delayed_xy_h40), delayed_call_fn, (delayed_xy_h40, )]
_handlers[g2.uid].append((bound, (0, )))
return tuple
def rgba_h41(g1, root, *args):
g1.rgba = root.color
def texture_h42(g2, root, *args):
g2.texture = root.texture
def size_h43(g2, root, *args):
g2.size = root.norm_image_size
def pos_h44(g2, root, *args):
root = root.__self__
g2.pos = root.center_x - root.norm_image_size[0] / 2., root.center_y - root.norm_image_size[1] / 2.
# <Image,AsyncImage> L105
def _r9(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.Rectangle()
root_canvas_root_add(g2)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b9(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b9, app, g1, g2, root))
def _b9(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h41 = [rgba_h41, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h41, None, None)
delayed_texture_h42 = [texture_h42, g2_ref, root_ref, None]
delayed_call_fn(delayed_texture_h42, None, None)
delayed_size_h43 = [size_h43, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h43, None, None)
delayed_pos_h44 = [pos_h44, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h44, None, None)
root_bound = bound = [None, ] * 6
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "color", bind("color", delayed_call_fn, delayed_rgba_h41), delayed_call_fn, (delayed_rgba_h41, )]
bound[1] = [None, None, None, root_ref, "texture", bind("texture", delayed_call_fn, delayed_texture_h42), delayed_call_fn, (delayed_texture_h42, )]
bound[2] = [None, None, None, root_ref, "norm_image_size", bind("norm_image_size", delayed_call_fn, delayed_size_h43), delayed_call_fn, (delayed_size_h43, )]
bound[3] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h44), delayed_call_fn, (delayed_pos_h44, )]
bound[4] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h44), delayed_call_fn, (delayed_pos_h44, )]
bound[5] = [None, None, None, root_ref, "norm_image_size", bind("norm_image_size", delayed_call_fn, delayed_pos_h44), delayed_call_fn, (delayed_pos_h44, )]
_handlers[g2.uid].append((bound, (1, 2, 3, 4, 5)))
_handlers[g1.uid].append((bound, (0, )))
return tuple
def xy_h45(g1, root, *args):
root = root.__self__
g1.xy = -root.x, -root.y
def texture_h46(g3, root, *args):
g3.texture = root.texture
def pos_h47(g3, root, *args):
g3.pos = root.pos
def size_h48(g3, root, *args):
g3.size = root.size
# <EffectWidget> L114
def _r10(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Translate()
root.canvas.before.add(g1)
g2 = Factory.Color()
root_canvas_root_add(g2)
g3 = Factory.Rectangle()
root_canvas_root_add(g3)
g2.rgba = 1, 1, 1, 1
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b10(app, g1, g2, g3, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b10, app, g1, g2, g3, root))
def _b10(app, g1, g2, g3, root):
g3_ref = g3.proxy_ref
root_ref = root.proxy_ref
delayed_xy_h45 = [xy_h45, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_xy_h45, None, None)
delayed_texture_h46 = [texture_h46, g3_ref, root_ref, None]
delayed_call_fn(delayed_texture_h46, None, None)
delayed_pos_h47 = [pos_h47, g3_ref, root_ref, None]
delayed_call_fn(delayed_pos_h47, None, None)
delayed_size_h48 = [size_h48, g3_ref, root_ref, None]
delayed_call_fn(delayed_size_h48, None, None)
root_bound = bound = [None, ] * 5
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_xy_h45), delayed_call_fn, (delayed_xy_h45, )]
bound[1] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_xy_h45), delayed_call_fn, (delayed_xy_h45, )]
bound[2] = [None, None, None, root_ref, "texture", bind("texture", delayed_call_fn, delayed_texture_h46), delayed_call_fn, (delayed_texture_h46, )]
bound[3] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h47), delayed_call_fn, (delayed_pos_h47, )]
bound[4] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h48), delayed_call_fn, (delayed_size_h48, )]
_handlers[g3.uid].append((bound, (2, 3, 4)))
_handlers[g1.uid].append((bound, (0, 1)))
return tuple
def rgba_h49(g1, root, *args):
root = root.__self__
g1.rgba = root.parent.background_color if root.parent else (1, 1, 1, 1)
def border_h50(g2, root, *args):
root = root.__self__
g2.border = root.parent.border if root.parent else (16, 16, 16, 16)
def source_h51(g2, root, *args):
root = root.__self__
g2.source = (root.parent.background_disabled_image if root.disabled else root.parent.background_image) if root.parent else None
def size_h52(g2, root, *args):
g2.size = root.size
def pos_h53(g2, root, *args):
g2.pos = root.pos
# <TabbedPanelContent> L126
_mc[11] = set()
def _r11(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.BorderImage()
root_canvas_root_add(g2)
if root.__class__ not in _mc[11]:
root_create_property = root.create_property
if not hasattr(root, "rows"):
root_create_property("rows", (1))
if not hasattr(root, "padding"):
root_create_property("padding", (3))
_mc[11].add(root.__class__)
root.rows = 1
root.padding = 3
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b11(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b11, app, g1, g2, root))
def _b11(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h49 = [rgba_h49, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h49, None, None)
delayed_border_h50 = [border_h50, g2_ref, root_ref, None]
delayed_call_fn(delayed_border_h50, None, None)
delayed_source_h51 = [source_h51, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h51, None, None)
delayed_size_h52 = [size_h52, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h52, None, None)
delayed_pos_h53 = [pos_h53, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h53, None, None)
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 11
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_rgba_h49), delayed_call_fn, (delayed_rgba_h49, )]
bound[1] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_border_h50), delayed_call_fn, (delayed_border_h50, )]
bound[2] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_source_h51), delayed_call_fn, (delayed_source_h51, )]
bound[3] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_source_h51), delayed_call_fn, (delayed_source_h51, )]
bound[4] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h52), delayed_call_fn, (delayed_size_h52, )]
bound[5] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h53), delayed_call_fn, (delayed_pos_h53, )]
if root.rebind_property("parent"):
bound[6] = [7, 11, None, root_ref, "parent", bind("parent", rebind_callback, bound, 6), rebind_callback, (bound, 6)]
if bound[6][5]:
prop = root.property("parent")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
else:
bound[6] = [7, 11, None, None, "parent", None, rebind_callback, (bound, 6)]
obj_root_parent = root.parent
if obj_root_parent is not None and isinstance(obj_root_parent, (EventDispatcher, Observable)):
obj_root_parent_ref = obj_root_parent.proxy_ref
bind = obj_root_parent.fast_bind
bound[7] = [None, None, 6, obj_root_parent_ref, "background_color", bind("background_color", delayed_call_fn, delayed_rgba_h49), delayed_call_fn, (delayed_rgba_h49, )]
bound[8] = [None, None, 6, obj_root_parent_ref, "border", bind("border", delayed_call_fn, delayed_border_h50), delayed_call_fn, (delayed_border_h50, )]
bound[9] = [None, None, 6, obj_root_parent_ref, "background_image", bind("background_image", delayed_call_fn, delayed_source_h51), delayed_call_fn, (delayed_source_h51, )]
bound[10] = [None, None, 6, obj_root_parent_ref, "background_disabled_image", bind("background_disabled_image", delayed_call_fn, delayed_source_h51), delayed_call_fn, (delayed_source_h51, )]
if bound[6] is not None and bound[7] is None:
bound[7] = [None, None, 6, None, "background_color", None, delayed_call_fn, (delayed_rgba_h49, )]
bound[8] = [None, None, 6, None, "border", None, delayed_call_fn, (delayed_border_h50, )]
bound[9] = [None, None, 6, None, "background_image", None, delayed_call_fn, (delayed_source_h51, )]
bound[10] = [None, None, 6, None, "background_disabled_image", None, delayed_call_fn, (delayed_source_h51, )]
_handlers[g2.uid].append((bound, (1, 2, 3, 4, 5, 8, 9, 10)))
_handlers[g1.uid].append((bound, (0, 7)))
return partial(_d11, root_bound, dispatch_objs, ())
def _d11(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
# <TabbedPanelStrip> L138
_mc[12] = set()
def _r12(root, builder_created):
if root.__class__ not in _mc[12]:
if not hasattr(root, "rows"):
root.create_property("rows", (1))
_mc[12].add(root.__class__)
root.rows = 1
def pos_h54(g1, root, *args):
g1.pos = root.pos
def size_h55(g1, root, *args):
g1.size = root.size
def border_h56(g1, root, *args):
g1.border = root.border
def source_h57(g1, root, *args):
g1.source = root.background_image
# <StripLayout> L141
_mc[13] = set()
def _r13(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
g1 = Factory.BorderImage()
root.canvas.before.add(g1)
if root.__class__ not in _mc[13]:
if not hasattr(root, "padding"):
root.create_property("padding", ('2dp', '2dp', '2dp', '2dp'))
_mc[13].add(root.__class__)
root.padding = '2dp', '2dp', '2dp', '2dp'
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b13(app, g1, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b13, app, g1, root))
def _b13(app, g1, root):
g1_ref = g1.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h54 = [pos_h54, g1_ref, root_ref, None]
delayed_call_fn(delayed_pos_h54, None, None)
delayed_size_h55 = [size_h55, g1_ref, root_ref, None]
delayed_call_fn(delayed_size_h55, None, None)
delayed_border_h56 = [border_h56, g1_ref, root_ref, None]
delayed_call_fn(delayed_border_h56, None, None)
delayed_source_h57 = [source_h57, g1_ref, root_ref, None]
delayed_call_fn(delayed_source_h57, None, None)
root_bound = bound = [None, ] * 4
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h54), delayed_call_fn, (delayed_pos_h54, )]
bound[1] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h55), delayed_call_fn, (delayed_size_h55, )]
bound[2] = [None, None, None, root_ref, "border", bind("border", delayed_call_fn, delayed_border_h56), delayed_call_fn, (delayed_border_h56, )]
bound[3] = [None, None, None, root_ref, "background_image", bind("background_image", delayed_call_fn, delayed_source_h57), delayed_call_fn, (delayed_source_h57, )]
_handlers[g1.uid].append((bound, (0, 1, 2, 3)))
return tuple
# <TabbedPanelHeader> L150
_mc[14] = set()
def _r14(root, builder_created):
if root.__class__ not in _mc[14]:
root_create_property = root.create_property
if not hasattr(root, "halign"):
root_create_property("halign", ('center'))
if not hasattr(root, "valign"):
root_create_property("valign", ('middle'))
if not hasattr(root, "background_normal"):
root_create_property("background_normal", ('atlas://data/images/defaulttheme/tab_btn'))
if not hasattr(root, "background_disabled_normal"):
root_create_property("background_disabled_normal", ('atlas://data/images/defaulttheme/tab_btn_disabled'))
if not hasattr(root, "background_down"):
root_create_property("background_down", ('atlas://data/images/defaulttheme/tab_btn_pressed'))
if not hasattr(root, "background_disabled_down"):
root_create_property("background_disabled_down", ('atlas://data/images/defaulttheme/tab_btn_pressed'))
if not hasattr(root, "border"):
root_create_property("border", ((8, 8, 8, 8)))
if not hasattr(root, "font_size"):
root_create_property("font_size", ('15sp'))
_mc[14].add(root.__class__)
root.halign = 'center'
root.valign = 'middle'
root.background_normal = 'atlas://data/images/defaulttheme/tab_btn'
root.background_disabled_normal = 'atlas://data/images/defaulttheme/tab_btn_disabled'
root.background_down = 'atlas://data/images/defaulttheme/tab_btn_pressed'
root.background_disabled_down = 'atlas://data/images/defaulttheme/tab_btn_pressed'
root.border = (8, 8, 8, 8)
root.font_size = '15sp'
# <Selector> L160
_mc[15] = set()
def _r15(root, builder_created):
if root.__class__ not in _mc[15]:
if not hasattr(root, "allow_stretch"):
root.create_property("allow_stretch", (None))
_mc[15].add(root.__class__)
root.allow_stretch = True
def rgba_h58(g1, root, *args):
g1.rgba = root.background_color
def border_h59(g2, root, *args):
g2.border = root.border
def pos_h60(g2, root, *args):
g2.pos = root.pos
def size_h61(g2, root, *args):
g2.size = root.size
def source_h62(g2, root, *args):
root = root.__self__
g2.source = (root.background_disabled_active if root.disabled else root.background_active) if root.focus else (root.background_disabled_normal if root.disabled else root.background_normal)
def rgba_h63(g3, root, *args):
root = root.__self__
g3.rgba = (root.cursor_color if root.focus and not root.cursor_blink else (0, 0, 0, 0))
def pos_h64(g4, root, *args):
g4.pos = [int(x) for x in root.cursor_pos]
def size_h65(g4, root, *args):
g4.size = 1, -root.line_height
def rgba_h66(g5, root, *args):
root = root.__self__
g5.rgba = root.disabled_foreground_color if root.disabled else (root.hint_text_color if not root.text and not root.focus else root.foreground_color)
# <TextInput> L163
def _r16(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Color = Factory.Color
root_canvas_before_add = root.canvas.before.add
g1 = cls_Color()
root_canvas_before_add(g1)
g2 = Factory.BorderImage()
root_canvas_before_add(g2)
g3 = cls_Color()
root_canvas_before_add(g3)
g4 = Factory.Rectangle()
root_canvas_before_add(g4)
g5 = cls_Color()
root_canvas_before_add(g5)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b16(app, g1, g2, g3, g4, g5, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b16, app, g1, g2, g3, g4, g5, root))
def _b16(app, g1, g2, g3, g4, g5, root):
g2_ref = g2.proxy_ref
g4_ref = g4.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h58 = [rgba_h58, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h58, None, None)
delayed_border_h59 = [border_h59, g2_ref, root_ref, None]
delayed_call_fn(delayed_border_h59, None, None)
delayed_pos_h60 = [pos_h60, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h60, None, None)
delayed_size_h61 = [size_h61, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h61, None, None)
delayed_source_h62 = [source_h62, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h62, None, None)
delayed_rgba_h63 = [rgba_h63, g3.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h63, None, None)
delayed_pos_h64 = [pos_h64, g4_ref, root_ref, None]
delayed_call_fn(delayed_pos_h64, None, None)
delayed_size_h65 = [size_h65, g4_ref, root_ref, None]
delayed_call_fn(delayed_size_h65, None, None)
delayed_rgba_h66 = [rgba_h66, g5.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h66, None, None)
root_bound = bound = [None, ] * 21
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "background_color", bind("background_color", delayed_call_fn, delayed_rgba_h58), delayed_call_fn, (delayed_rgba_h58, )]
bound[1] = [None, None, None, root_ref, "border", bind("border", delayed_call_fn, delayed_border_h59), delayed_call_fn, (delayed_border_h59, )]
bound[2] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h60), delayed_call_fn, (delayed_pos_h60, )]
bound[3] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h61), delayed_call_fn, (delayed_size_h61, )]
bound[4] = [None, None, None, root_ref, "background_disabled_normal", bind("background_disabled_normal", delayed_call_fn, delayed_source_h62), delayed_call_fn, (delayed_source_h62, )]
bound[5] = [None, None, None, root_ref, "background_active", bind("background_active", delayed_call_fn, delayed_source_h62), delayed_call_fn, (delayed_source_h62, )]
bound[6] = [None, None, None, root_ref, "background_normal", bind("background_normal", delayed_call_fn, delayed_source_h62), delayed_call_fn, (delayed_source_h62, )]
bound[7] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_source_h62), delayed_call_fn, (delayed_source_h62, )]
bound[8] = [None, None, None, root_ref, "focus", bind("focus", delayed_call_fn, delayed_source_h62), delayed_call_fn, (delayed_source_h62, )]
bound[9] = [None, None, None, root_ref, "background_disabled_active", bind("background_disabled_active", delayed_call_fn, delayed_source_h62), delayed_call_fn, (delayed_source_h62, )]
bound[10] = [None, None, None, root_ref, "cursor_blink", bind("cursor_blink", delayed_call_fn, delayed_rgba_h63), delayed_call_fn, (delayed_rgba_h63, )]
bound[11] = [None, None, None, root_ref, "focus", bind("focus", delayed_call_fn, delayed_rgba_h63), delayed_call_fn, (delayed_rgba_h63, )]
bound[12] = [None, None, None, root_ref, "cursor_color", bind("cursor_color", delayed_call_fn, delayed_rgba_h63), delayed_call_fn, (delayed_rgba_h63, )]
bound[13] = [None, None, None, root_ref, "cursor_pos", bind("cursor_pos", delayed_call_fn, delayed_pos_h64), delayed_call_fn, (delayed_pos_h64, )]
bound[14] = [None, None, None, root_ref, "line_height", bind("line_height", delayed_call_fn, delayed_size_h65), delayed_call_fn, (delayed_size_h65, )]
bound[15] = [None, None, None, root_ref, "text", bind("text", delayed_call_fn, delayed_rgba_h66), delayed_call_fn, (delayed_rgba_h66, )]
bound[16] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", delayed_call_fn, delayed_rgba_h66), delayed_call_fn, (delayed_rgba_h66, )]
bound[17] = [None, None, None, root_ref, "hint_text_color", bind("hint_text_color", delayed_call_fn, delayed_rgba_h66), delayed_call_fn, (delayed_rgba_h66, )]
bound[18] = [None, None, None, root_ref, "disabled_foreground_color", bind("disabled_foreground_color", delayed_call_fn, delayed_rgba_h66), delayed_call_fn, (delayed_rgba_h66, )]
bound[19] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_rgba_h66), delayed_call_fn, (delayed_rgba_h66, )]
bound[20] = [None, None, None, root_ref, "focus", bind("focus", delayed_call_fn, delayed_rgba_h66), delayed_call_fn, (delayed_rgba_h66, )]
_handlers[g5.uid].append((bound, (15, 16, 17, 18, 19, 20)))
_handlers[g4.uid].append((bound, (13, 14)))
_handlers[g3.uid].append((bound, (10, 11, 12)))
_handlers[g2.uid].append((bound, (1, 2, 3, 4, 5, 6, 7, 8, 9)))
_handlers[g1.uid].append((bound, (0, )))
return tuple
def but_cut_h67(root, w1_cut, *args):
root.but_cut = w1_cut.__self__
def but_copy_h68(root, w2_copy, *args):
root.but_copy = w2_copy.__self__
def but_paste_h69(root, w3_paste, *args):
root.but_paste = w3_paste.__self__
def but_selectall_h70(root, w4_selectall, *args):
root.but_selectall = w4_selectall.__self__
def on_on_release_h0(root, *args):
root.do('cut')
def on_on_release_h1(root, *args):
root.do('copy')
def on_on_release_h2(root, *args):
root.do('paste')
def on_on_release_h3(root, *args):
root.do('selectall')
# <TextInputCutCopyPaste> L180
_mc[17] = set()
def _r17(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_BubbleButton = Factory.BubbleButton
w1_cut = cls_BubbleButton(parent=root, __builder_created=bfuncs)
w2_copy = cls_BubbleButton(parent=root, __builder_created=bfuncs)
w3_paste = cls_BubbleButton(parent=root, __builder_created=bfuncs)
w4_selectall = cls_BubbleButton(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[17]:
root_create_property = root.create_property
if not hasattr(root, "but_cut"):
root_create_property("but_cut", (None))
if not hasattr(root, "but_copy"):
root_create_property("but_copy", (None))
if not hasattr(root, "but_paste"):
root_create_property("but_paste", (None))
if not hasattr(root, "but_selectall"):
root_create_property("but_selectall", (None))
if not hasattr(root, "size_hint"):
root_create_property("size_hint", (None))
if not hasattr(root, "size"):
root_create_property("size", ('150sp', '50sp'))
if not hasattr(w1_cut, "text"):
w1_cut.create_property("text", ('Cut'))
if not hasattr(w2_copy, "text"):
w2_copy.create_property("text", ('Copy'))
if not hasattr(w3_paste, "text"):
w3_paste.create_property("text", ('Paste'))
if not hasattr(w4_selectall, "text"):
w4_selectall.create_property("text", ('Select All'))
_mc[17].add(root.__class__)
root.size_hint = None, None
root.size = '150sp', '50sp'
w1_cut.text = 'Cut'
w2_copy.text = 'Copy'
w3_paste.text = 'Paste'
w4_selectall.text = 'Select All'
root.but_cut = w1_cut.__self__
root.but_copy = w2_copy.__self__
root.but_paste = w3_paste.__self__
root.but_selectall = w4_selectall.__self__
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b17(app, root, w1_cut, w2_copy, w3_paste, w4_selectall))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b17, app, root, w1_cut, w2_copy, w3_paste, w4_selectall))
def _b17(app, root, w1_cut, w2_copy, w3_paste, w4_selectall):
root_ref = root.proxy_ref
w1_cut_ref = w1_cut.proxy_ref
w2_copy_ref = w2_copy.proxy_ref
w3_paste_ref = w3_paste.proxy_ref
w4_selectall_ref = w4_selectall.proxy_ref
dispatch_objs = [None, ] * 4
w1_cut_bound = bound = [None, ] * 1
bind = w1_cut.fast_bind
bind("on_release", on_on_release_h0, root_ref)
prop = w1_cut.property("on_release", quiet=True)
if prop is not None:
dispatch_objs[0] = [w1_cut, prop, prop.dispatch_count(w1_cut)]
bound[0] = [None, None, None, w1_cut_ref, "__self__", bind("__self__", but_cut_h67, root_ref, w1_cut_ref), but_cut_h67, [root_ref, w1_cut_ref]]
_handlers[root.uid].append((bound, (0, )))
w2_copy_bound = bound = [None, ] * 1
bind = w2_copy.fast_bind
bind("on_release", on_on_release_h1, root_ref)
prop = w2_copy.property("on_release", quiet=True)
if prop is not None:
dispatch_objs[1] = [w2_copy, prop, prop.dispatch_count(w2_copy)]
bound[0] = [None, None, None, w2_copy_ref, "__self__", bind("__self__", but_copy_h68, root_ref, w2_copy_ref), but_copy_h68, [root_ref, w2_copy_ref]]
_handlers[root.uid].append((bound, (0, )))
w3_paste_bound = bound = [None, ] * 1
bind = w3_paste.fast_bind
bind("on_release", on_on_release_h2, root_ref)
prop = w3_paste.property("on_release", quiet=True)
if prop is not None:
dispatch_objs[2] = [w3_paste, prop, prop.dispatch_count(w3_paste)]
bound[0] = [None, None, None, w3_paste_ref, "__self__", bind("__self__", but_paste_h69, root_ref, w3_paste_ref), but_paste_h69, [root_ref, w3_paste_ref]]
_handlers[root.uid].append((bound, (0, )))
w4_selectall_bound = bound = [None, ] * 1
bind = w4_selectall.fast_bind
bind("on_release", on_on_release_h3, root_ref)
prop = w4_selectall.property("on_release", quiet=True)
if prop is not None:
dispatch_objs[3] = [w4_selectall, prop, prop.dispatch_count(w4_selectall)]
bound[0] = [None, None, None, w4_selectall_ref, "__self__", bind("__self__", but_selectall_h70, root_ref, w4_selectall_ref), but_selectall_h70, [root_ref, w4_selectall_ref]]
_handlers[root.uid].append((bound, (0, )))
return partial(_d17, w4_selectall_bound, w1_cut_bound, w3_paste_bound, w2_copy_bound, dispatch_objs, (w1_cut, w2_copy, w3_paste, w4_selectall))
def _d17(w4_selectall_bound, w1_cut_bound, w3_paste_bound, w2_copy_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
return widgets
# <CodeInput> L205
_mc[18] = set()
def _r18(root, builder_created):
if root.__class__ not in _mc[18]:
if not hasattr(root, "font_name"):
root.create_property("font_name", ('data/fonts/DroidSansMono.ttf'))
_mc[18].add(root.__class__)
root.font_name = 'data/fonts/DroidSansMono.ttf'
def rgba_h71(g1, root, *args):
root = root.__self__
g1.rgba = root.color_selected if root.is_selected else root.odd_color if root.odd else root.even_color
def pos_h72(g2, root, *args):
root = root.__self__
g2.pos = [root.parent.x, root.y] if root.parent else [0, 0]
def size_h73(g2, root, *args):
root = root.__self__
g2.size = [root.parent.width, root.height] if root.parent else [1, 1]
def rgba_h74(g3, root, *args):
g3.rgba = 1, 1, 1, int(not root.is_leaf)
def source_h75(g4, root, *args):
g4.source = 'atlas://data/images/defaulttheme/tree_%s' % ('opened' if root.is_open else 'closed')
def pos_h76(g4, root, *args):
root = root.__self__
g4.pos = root.x - 20, root.center_y - 8
def points_h77(g6, root, *args):
root = root.__self__
g6.points = [root.parent.x, root.y, root.parent.right, root.y] if root.parent else []
# <TreeViewNode> L209
def _r19(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Color = Factory.Color
cls_Rectangle = Factory.Rectangle
root_canvas_before_add = root.canvas.before.add
root_canvas_after_add = root.canvas.after.add
g1 = cls_Color()
root_canvas_before_add(g1)
g2 = cls_Rectangle()
root_canvas_before_add(g2)
g3 = cls_Color()
root_canvas_before_add(g3)
g4 = cls_Rectangle()
root_canvas_before_add(g4)
g5 = cls_Color()
root_canvas_after_add(g5)
g6 = Factory.Line()
root_canvas_after_add(g6)
g4.size = 16, 16
g5.rgba = .5, .5, .5, .2
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b19(app, g1, g2, g3, g4, g5, g6, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b19, app, g1, g2, g3, g4, g5, g6, root))
def _b19(app, g1, g2, g3, g4, g5, g6, root):
g2_ref = g2.proxy_ref
g4_ref = g4.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h71 = [rgba_h71, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h71, None, None)
delayed_pos_h72 = [pos_h72, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h72, None, None)
delayed_size_h73 = [size_h73, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h73, None, None)
delayed_rgba_h74 = [rgba_h74, g3.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h74, None, None)
delayed_source_h75 = [source_h75, g4_ref, root_ref, None]
delayed_call_fn(delayed_source_h75, None, None)
delayed_pos_h76 = [pos_h76, g4_ref, root_ref, None]
delayed_call_fn(delayed_pos_h76, None, None)
delayed_points_h77 = [points_h77, g6.proxy_ref, root_ref, None]
delayed_call_fn(delayed_points_h77, None, None)
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 20
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "is_selected", bind("is_selected", delayed_call_fn, delayed_rgba_h71), delayed_call_fn, (delayed_rgba_h71, )]
bound[1] = [None, None, None, root_ref, "odd_color", bind("odd_color", delayed_call_fn, delayed_rgba_h71), delayed_call_fn, (delayed_rgba_h71, )]
bound[2] = [None, None, None, root_ref, "odd", bind("odd", delayed_call_fn, delayed_rgba_h71), delayed_call_fn, (delayed_rgba_h71, )]
bound[3] = [None, None, None, root_ref, "color_selected", bind("color_selected", delayed_call_fn, delayed_rgba_h71), delayed_call_fn, (delayed_rgba_h71, )]
bound[4] = [None, None, None, root_ref, "even_color", bind("even_color", delayed_call_fn, delayed_rgba_h71), delayed_call_fn, (delayed_rgba_h71, )]
bound[5] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h72), delayed_call_fn, (delayed_pos_h72, )]
bound[6] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_pos_h72), delayed_call_fn, (delayed_pos_h72, )]
bound[7] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_size_h73), delayed_call_fn, (delayed_size_h73, )]
bound[8] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_size_h73), delayed_call_fn, (delayed_size_h73, )]
bound[9] = [None, None, None, root_ref, "is_leaf", bind("is_leaf", delayed_call_fn, delayed_rgba_h74), delayed_call_fn, (delayed_rgba_h74, )]
bound[10] = [None, None, None, root_ref, "is_open", bind("is_open", delayed_call_fn, delayed_source_h75), delayed_call_fn, (delayed_source_h75, )]
bound[11] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h76), delayed_call_fn, (delayed_pos_h76, )]
bound[12] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h76), delayed_call_fn, (delayed_pos_h76, )]
bound[13] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_points_h77), delayed_call_fn, (delayed_points_h77, )]
bound[14] = [None, None, None, root_ref, "parent", bind("parent", delayed_call_fn, delayed_points_h77), delayed_call_fn, (delayed_points_h77, )]
if root.rebind_property("parent"):
bound[15] = [16, 20, None, root_ref, "parent", bind("parent", rebind_callback, bound, 15), rebind_callback, (bound, 15)]
if bound[15][5]:
prop = root.property("parent")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
else:
bound[15] = [16, 20, None, None, "parent", None, rebind_callback, (bound, 15)]
obj_root_parent = root.parent
if obj_root_parent is not None and isinstance(obj_root_parent, (EventDispatcher, Observable)):
obj_root_parent_ref = obj_root_parent.proxy_ref
bind = obj_root_parent.fast_bind
bound[16] = [None, None, 15, obj_root_parent_ref, "x", bind("x", delayed_call_fn, delayed_pos_h72), delayed_call_fn, (delayed_pos_h72, )]
bound[17] = [None, None, 15, obj_root_parent_ref, "width", bind("width", delayed_call_fn, delayed_size_h73), delayed_call_fn, (delayed_size_h73, )]
bound[18] = [None, None, 15, obj_root_parent_ref, "x", bind("x", delayed_call_fn, delayed_points_h77), delayed_call_fn, (delayed_points_h77, )]
bound[19] = [None, None, 15, obj_root_parent_ref, "right", bind("right", delayed_call_fn, delayed_points_h77), delayed_call_fn, (delayed_points_h77, )]
if bound[15] is not None and bound[16] is None:
bound[16] = [None, None, 15, None, "x", None, delayed_call_fn, (delayed_pos_h72, )]
bound[17] = [None, None, 15, None, "width", None, delayed_call_fn, (delayed_size_h73, )]
bound[18] = [None, None, 15, None, "x", None, delayed_call_fn, (delayed_points_h77, )]
bound[19] = [None, None, 15, None, "right", None, delayed_call_fn, (delayed_points_h77, )]
_handlers[g6.uid].append((bound, (13, 14, 18, 19)))
_handlers[g4.uid].append((bound, (10, 11, 12)))
_handlers[g3.uid].append((bound, (9, )))
_handlers[g2.uid].append((bound, (5, 6, 7, 8, 16, 17)))
_handlers[g1.uid].append((bound, (0, 1, 2, 3, 4)))
return partial(_d19, root_bound, dispatch_objs, ())
def _d19(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def width_h78(root, *args):
root.width = root.texture_size[0]
def height_h79(root, *args):
root.height = max(root.texture_size[1] + dp(10), dp(24))
def text_size_h80(root, *args):
root.text_size = root.width, None
# <TreeViewLabel> L229
_mc[20] = set()
def _r20(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
if root.__class__ not in _mc[20]:
root_create_property = root.create_property
if not hasattr(root, "width"):
root_create_property("width", (None))
if not hasattr(root, "height"):
root_create_property("height", (None))
if not hasattr(root, "text_size"):
root_create_property("text_size", (None))
_mc[20].add(root.__class__)
root.width = root.texture_size[0]
root.height = max(root.texture_size[1] + dp(10), dp(24))
root.text_size = root.width, None
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b20(app, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b20, app, root))
def _b20(app, root):
root_ref = root.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 3
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "texture_size", bind("texture_size", width_h78, root_ref), width_h78, (root_ref, )]
if bound[0][5]:
prop = root.property("texture_size")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "texture_size", bind("texture_size", height_h79, root_ref), height_h79, (root_ref, )]
bound[2] = [None, None, None, root_ref, "width", bind("width", text_size_h80, root_ref), text_size_h80, (root_ref, )]
_handlers[root.uid].append((bound, (0, 1, 2)))
return partial(_d20, root_bound, dispatch_objs, ())
def _d20(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def pos_h81(g2, root, *args):
g2.pos = root.pos
def size_h82(g2, root, *args):
g2.size = root.size
def pos_h83(g5, root, *args):
g5.pos = root.pos
def size_h84(g5, root, *args):
g5.size = root.size
# <StencilView> L235
def _r21(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Rectangle = Factory.Rectangle
root_canvas_before_add = root.canvas.before.add
root_canvas_after_add = root.canvas.after.add
g1 = Factory.StencilPush()
root_canvas_before_add(g1)
g2 = cls_Rectangle()
root_canvas_before_add(g2)
g3 = Factory.StencilUse()
root_canvas_before_add(g3)
g4 = Factory.StencilUnUse()
root_canvas_after_add(g4)
g5 = cls_Rectangle()
root_canvas_after_add(g5)
g6 = Factory.StencilPop()
root_canvas_after_add(g6)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b21(app, g1, g2, g3, g4, g5, g6, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b21, app, g1, g2, g3, g4, g5, g6, root))
def _b21(app, g1, g2, g3, g4, g5, g6, root):
g2_ref = g2.proxy_ref
g5_ref = g5.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h81 = [pos_h81, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h81, None, None)
delayed_size_h82 = [size_h82, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h82, None, None)
delayed_pos_h83 = [pos_h83, g5_ref, root_ref, None]
delayed_call_fn(delayed_pos_h83, None, None)
delayed_size_h84 = [size_h84, g5_ref, root_ref, None]
delayed_call_fn(delayed_size_h84, None, None)
root_bound = bound = [None, ] * 4
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h81), delayed_call_fn, (delayed_pos_h81, )]
bound[1] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h82), delayed_call_fn, (delayed_size_h82, )]
bound[2] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h83), delayed_call_fn, (delayed_pos_h83, )]
bound[3] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h84), delayed_call_fn, (delayed_size_h84, )]
_handlers[g5.uid].append((bound, (2, 3)))
_handlers[g2.uid].append((bound, (0, 1)))
return tuple
def pos_h85(root, w1, *args):
w1.pos = root.pos
def size_h86(root, w1, *args):
w1.size = root.size
def text_size_h87(w4, *args):
w4.text_size = w4.size
def text_size_h88(w5, *args):
w5.text_size = w5.size
def size_h89(w8, w9_treeview, *args):
w8.size = w9_treeview.size
def width_h90(w7_scrollview, w9_treeview, *args):
w9_treeview.width = w7_scrollview.width
def height_h91(w9_treeview, *args):
w9_treeview.height = w9_treeview.minimum_height
def on_on_entry_added_h4(w9_treeview, *args):
w9_treeview.add_node(args[1])
def on_on_entries_cleared_h5(w9_treeview, *args):
w9_treeview.root.nodes = []
def on_on_subentry_to_entry_h6(w9_treeview, *args):
not args[2].locked and w9_treeview.add_node(args[1], args[2])
def on_on_remove_subentry_h7(*args):
args[2].nodes = []
def on_on_node_expand_h8(root, *args):
root.controller.entry_subselect(args[1])
def on_on_node_collapse_h9(root, *args):
root.controller.close_subselection(args[1])
# <FileChooserListLayout> L251
_mc[22] = set()
def _r22(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_BoxLayout = Factory.BoxLayout
cls_Widget = Factory.Widget
cls_Label = Factory.Label
w1 = cls_BoxLayout(parent=root, __builder_created=bfuncs)
w2 = cls_BoxLayout(parent=w1, __builder_created=bfuncs)
w3 = cls_Widget(parent=w2, __builder_created=bfuncs)
w4 = cls_Label(parent=w2, __builder_created=bfuncs)
w5 = cls_Label(parent=w2, __builder_created=bfuncs)
w6 = cls_Widget(parent=w2, __builder_created=bfuncs)
w7_scrollview = Factory.ScrollView(parent=w1, __builder_created=bfuncs)
w8 = Factory.Scatter(parent=w7_scrollview, __builder_created=bfuncs)
w9_treeview = Factory.TreeView(parent=w8, __builder_created=bfuncs)
if root.__class__ not in _mc[22]:
w1_create_property = w1.create_property
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "size"):
w1_create_property("size", (None))
if not hasattr(w1, "size_hint"):
w1_create_property("size_hint", (None))
if not hasattr(w1, "orientation"):
w1_create_property("orientation", ('vertical'))
w2_create_property = w2.create_property
if not hasattr(w2, "size_hint_y"):
w2_create_property("size_hint_y", (None))
if not hasattr(w2, "height"):
w2_create_property("height", (30))
if not hasattr(w2, "orientation"):
w2_create_property("orientation", ('horizontal'))
w3_create_property = w3.create_property
if not hasattr(w3, "width"):
w3_create_property("width", (10))
if not hasattr(w3, "size_hint_x"):
w3_create_property("size_hint_x", (None))
w4_create_property = w4.create_property
if not hasattr(w4, "text"):
w4_create_property("text", ('Name'))
if not hasattr(w4, "text_size"):
w4_create_property("text_size", (None))
if not hasattr(w4, "halign"):
w4_create_property("halign", ('left'))
if not hasattr(w4, "bold"):
w4_create_property("bold", (None))
w5_create_property = w5.create_property
if not hasattr(w5, "text"):
w5_create_property("text", ('Size'))
if not hasattr(w5, "text_size"):
w5_create_property("text_size", (None))
if not hasattr(w5, "size_hint_x"):
w5_create_property("size_hint_x", (None))
if not hasattr(w5, "halign"):
w5_create_property("halign", ('right'))
if not hasattr(w5, "bold"):
w5_create_property("bold", (None))
w6_create_property = w6.create_property
if not hasattr(w6, "width"):
w6_create_property("width", (10))
if not hasattr(w6, "size_hint_x"):
w6_create_property("size_hint_x", (None))
if not hasattr(w7_scrollview, "do_scroll_x"):
w7_scrollview.create_property("do_scroll_x", (None))
w8_create_property = w8.create_property
if not hasattr(w8, "do_rotation"):
w8_create_property("do_rotation", (None))
if not hasattr(w8, "do_scale"):
w8_create_property("do_scale", (None))
if not hasattr(w8, "do_translation"):
w8_create_property("do_translation", (None))
if not hasattr(w8, "size"):
w8_create_property("size", (None))
if not hasattr(w8, "size_hint_y"):
w8_create_property("size_hint_y", (None))
w9_treeview_create_property = w9_treeview.create_property
if not hasattr(w9_treeview, "hide_root"):
w9_treeview_create_property("hide_root", (None))
if not hasattr(w9_treeview, "size_hint_y"):
w9_treeview_create_property("size_hint_y", (None))
if not hasattr(w9_treeview, "width"):
w9_treeview_create_property("width", (None))
if not hasattr(w9_treeview, "height"):
w9_treeview_create_property("height", (None))
_mc[22].add(root.__class__)
w1.size_hint = None, None
w1.orientation = 'vertical'
w2.size_hint_y = None
w2.height = 30
w2.orientation = 'horizontal'
w3.width = 10
w3.size_hint_x = None
w4.text = 'Name'
w4.halign = 'left'
w4.bold = True
w5.text = 'Size'
w5.size_hint_x = None
w5.halign = 'right'
w5.bold = True
w6.width = 10
w6.size_hint_x = None
w7_scrollview.do_scroll_x = False
w8.do_rotation = False
w8.do_scale = False
w8.do_translation = False
w8.size_hint_y = None
w9_treeview.hide_root = True
w9_treeview.size_hint_y = None
w1.pos = root.pos
w1.size = root.size
w4.text_size = w4.size
w5.text_size = w5.size
w8.size = w9_treeview.size
w9_treeview.width = w7_scrollview.width
w9_treeview.height = w9_treeview.minimum_height
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b22(app, root, w1, w2, w3, w4, w5, w6, w7_scrollview, w8, w9_treeview))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b22, app, root, w1, w2, w3, w4, w5, w6, w7_scrollview, w8, w9_treeview))
def _b22(app, root, w1, w2, w3, w4, w5, w6, w7_scrollview, w8, w9_treeview):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w4_ref = w4.proxy_ref
w5_ref = w5.proxy_ref
w7_scrollview_ref = w7_scrollview.proxy_ref
w8_ref = w8.proxy_ref
w9_treeview_ref = w9_treeview.proxy_ref
dispatch_objs = [None, ] * 10
root_bound = bound = [None, ] * 2
bind = root.fast_bind
root_get_prop = root.property
bind("on_entry_added", on_on_entry_added_h4, w9_treeview_ref)
prop = root_get_prop("on_entry_added", quiet=True)
if prop is not None:
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bind("on_entries_cleared", on_on_entries_cleared_h5, w9_treeview_ref)
prop = root_get_prop("on_entries_cleared", quiet=True)
if prop is not None:
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bind("on_subentry_to_entry", on_on_subentry_to_entry_h6, w9_treeview_ref)
prop = root_get_prop("on_subentry_to_entry", quiet=True)
if prop is not None:
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bind("on_remove_subentry", on_on_remove_subentry_h7)
prop = root_get_prop("on_remove_subentry", quiet=True)
if prop is not None:
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h85, root_ref, w1_ref), pos_h85, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("pos")
dispatch_objs[4] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "size", bind("size", size_h86, root_ref, w1_ref), size_h86, [root_ref, w1_ref]]
if bound[1][5]:
prop = root_get_prop("size")
dispatch_objs[5] = [root, prop, prop.dispatch_count(root)]
_handlers[w1.uid].append((bound, (0, 1)))
w4_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w4_ref, "size", w4.fast_bind("size", text_size_h87, w4_ref), text_size_h87, (w4_ref, )]
_handlers[w4.uid].append((bound, (0, )))
w5_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w5_ref, "size", w5.fast_bind("size", text_size_h88, w5_ref), text_size_h88, (w5_ref, )]
_handlers[w5.uid].append((bound, (0, )))
w7_scrollview_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w7_scrollview_ref, "width", w7_scrollview.fast_bind("width", width_h90, w7_scrollview_ref, w9_treeview_ref), width_h90, [w7_scrollview_ref, w9_treeview_ref]]
if bound[0][5]:
prop = w7_scrollview.property("width")
dispatch_objs[6] = [w7_scrollview, prop, prop.dispatch_count(w7_scrollview)]
_handlers[w9_treeview.uid].append((bound, (0, )))
w9_treeview_bound = bound = [None, ] * 2
bind = w9_treeview.fast_bind
w9_treeview_get_prop = w9_treeview.property
bind("on_node_expand", on_on_node_expand_h8, root_ref)
prop = w9_treeview_get_prop("on_node_expand", quiet=True)
if prop is not None:
dispatch_objs[7] = [w9_treeview, prop, prop.dispatch_count(w9_treeview)]
bind("on_node_collapse", on_on_node_collapse_h9, root_ref)
prop = w9_treeview_get_prop("on_node_collapse", quiet=True)
if prop is not None:
dispatch_objs[8] = [w9_treeview, prop, prop.dispatch_count(w9_treeview)]
bound[0] = [None, None, None, w9_treeview_ref, "size", bind("size", size_h89, w8_ref, w9_treeview_ref), size_h89, [w8_ref, w9_treeview_ref]]
if bound[0][5]:
prop = w9_treeview_get_prop("size")
dispatch_objs[9] = [w9_treeview, prop, prop.dispatch_count(w9_treeview)]
bound[1] = [None, None, None, w9_treeview_ref, "minimum_height", bind("minimum_height", height_h91, w9_treeview_ref), height_h91, (w9_treeview_ref, )]
_handlers[w9_treeview.uid].append((bound, (1, )))
_handlers[w8.uid].append((bound, (0, )))
return partial(_d22, w7_scrollview_bound, w5_bound, w4_bound, root_bound, w9_treeview_bound, dispatch_objs, (w1, w2, w3, w4, w5, w6, w7_scrollview, w8, w9_treeview))
def _d22(w7_scrollview_bound, w5_bound, w4_bound, root_bound, w9_treeview_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
if dispatch_objs[5] is not None:
obj, prop, count = dispatch_objs[5]
prop.dispatch_stale(obj, count)
if dispatch_objs[6] is not None:
obj, prop, count = dispatch_objs[6]
prop.dispatch_stale(obj, count)
if dispatch_objs[7] is not None:
obj, prop, count = dispatch_objs[7]
prop.dispatch_stale(obj, count)
if dispatch_objs[8] is not None:
obj, prop, count = dispatch_objs[8]
prop.dispatch_stale(obj, count)
if dispatch_objs[9] is not None:
obj, prop, count = dispatch_objs[9]
prop.dispatch_stale(obj, count)
return widgets
def pos_h92(root, w1_layout, *args):
w1_layout.pos = root.pos
# <FileChooserListView> L302
_mc[23] = set()
def _r23(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_layout = Factory.FileChooserListLayout(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[23]:
if not hasattr(root, "layout"):
root.create_property("layout", (None))
w1_layout_create_property = w1_layout.create_property
if not hasattr(w1_layout, "controller"):
w1_layout_create_property("controller", (None))
if not hasattr(w1_layout, "pos"):
w1_layout_create_property("pos", (None))
_mc[23].add(root.__class__)
root.layout = w1_layout
w1_layout.controller = root
w1_layout.pos = root.pos
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b23(app, root, w1_layout))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b23, app, root, w1_layout))
def _b23(app, root, w1_layout):
root_ref = root.proxy_ref
w1_layout_ref = w1_layout.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "pos", root.fast_bind("pos", pos_h92, root_ref, w1_layout_ref), pos_h92, [root_ref, w1_layout_ref]]
if bound[0][5]:
prop = root.property("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
_handlers[w1_layout.uid].append((bound, (0, )))
return partial(_d23, root_bound, dispatch_objs, (w1_layout, ))
def _d23(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def pos_h93(root, w1_scrollview, *args):
w1_scrollview.pos = root.pos
def size_h94(root, w1_scrollview, *args):
w1_scrollview.size = root.size
def height_h95(w2, w3_stacklayout, *args):
w2.height = w3_stacklayout.height
def width_h96(w1_scrollview, w3_stacklayout, *args):
w3_stacklayout.width = w1_scrollview.width
def height_h97(w3_stacklayout, *args):
w3_stacklayout.height = w3_stacklayout.minimum_height
def on_on_entry_added_h10(w3_stacklayout, *args):
w3_stacklayout.add_widget(args[1])
def on_on_entries_cleared_h11(w3_stacklayout, *args):
w3_stacklayout.clear_widgets()
# <FileChooserIconLayout> L341
_mc[24] = set()
def _r24(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_scrollview = Factory.ScrollView(parent=root, __builder_created=bfuncs)
w2 = Factory.Scatter(parent=w1_scrollview, __builder_created=bfuncs)
w3_stacklayout = Factory.StackLayout(parent=w2, __builder_created=bfuncs)
if root.__class__ not in _mc[24]:
w1_scrollview_create_property = w1_scrollview.create_property
if not hasattr(w1_scrollview, "pos"):
w1_scrollview_create_property("pos", (None))
if not hasattr(w1_scrollview, "size"):
w1_scrollview_create_property("size", (None))
if not hasattr(w1_scrollview, "size_hint"):
w1_scrollview_create_property("size_hint", (None))
if not hasattr(w1_scrollview, "do_scroll_x"):
w1_scrollview_create_property("do_scroll_x", (None))
w2_create_property = w2.create_property
if not hasattr(w2, "do_rotation"):
w2_create_property("do_rotation", (None))
if not hasattr(w2, "do_scale"):
w2_create_property("do_scale", (None))
if not hasattr(w2, "do_translation"):
w2_create_property("do_translation", (None))
if not hasattr(w2, "size_hint_y"):
w2_create_property("size_hint_y", (None))
if not hasattr(w2, "height"):
w2_create_property("height", (None))
w3_stacklayout_create_property = w3_stacklayout.create_property
if not hasattr(w3_stacklayout, "width"):
w3_stacklayout_create_property("width", (None))
if not hasattr(w3_stacklayout, "size_hint_y"):
w3_stacklayout_create_property("size_hint_y", (None))
if not hasattr(w3_stacklayout, "height"):
w3_stacklayout_create_property("height", (None))
if not hasattr(w3_stacklayout, "spacing"):
w3_stacklayout_create_property("spacing", ('10dp'))
if not hasattr(w3_stacklayout, "padding"):
w3_stacklayout_create_property("padding", ('10dp'))
_mc[24].add(root.__class__)
w1_scrollview.size_hint = None, None
w1_scrollview.do_scroll_x = False
w2.do_rotation = False
w2.do_scale = False
w2.do_translation = False
w2.size_hint_y = None
w3_stacklayout.size_hint_y = None
w3_stacklayout.spacing = '10dp'
w3_stacklayout.padding = '10dp'
w1_scrollview.pos = root.pos
w1_scrollview.size = root.size
w2.height = w3_stacklayout.height
w3_stacklayout.width = w1_scrollview.width
w3_stacklayout.height = w3_stacklayout.minimum_height
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b24(app, root, w1_scrollview, w2, w3_stacklayout))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b24, app, root, w1_scrollview, w2, w3_stacklayout))
def _b24(app, root, w1_scrollview, w2, w3_stacklayout):
root_ref = root.proxy_ref
w1_scrollview_ref = w1_scrollview.proxy_ref
w2_ref = w2.proxy_ref
w3_stacklayout_ref = w3_stacklayout.proxy_ref
dispatch_objs = [None, ] * 7
root_bound = bound = [None, ] * 2
bind = root.fast_bind
root_get_prop = root.property
bind("on_entry_added", on_on_entry_added_h10, w3_stacklayout_ref)
prop = root_get_prop("on_entry_added", quiet=True)
if prop is not None:
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bind("on_entries_cleared", on_on_entries_cleared_h11, w3_stacklayout_ref)
prop = root_get_prop("on_entries_cleared", quiet=True)
if prop is not None:
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h93, root_ref, w1_scrollview_ref), pos_h93, [root_ref, w1_scrollview_ref]]
if bound[0][5]:
prop = root_get_prop("pos")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "size", bind("size", size_h94, root_ref, w1_scrollview_ref), size_h94, [root_ref, w1_scrollview_ref]]
if bound[1][5]:
prop = root_get_prop("size")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
_handlers[w1_scrollview.uid].append((bound, (0, 1)))
w1_scrollview_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w1_scrollview_ref, "width", w1_scrollview.fast_bind("width", width_h96, w1_scrollview_ref, w3_stacklayout_ref), width_h96, [w1_scrollview_ref, w3_stacklayout_ref]]
if bound[0][5]:
prop = w1_scrollview.property("width")
dispatch_objs[4] = [w1_scrollview, prop, prop.dispatch_count(w1_scrollview)]
_handlers[w3_stacklayout.uid].append((bound, (0, )))
w3_stacklayout_bound = bound = [None, ] * 2
bind = w3_stacklayout.fast_bind
w3_stacklayout_get_prop = w3_stacklayout.property
bound[0] = [None, None, None, w3_stacklayout_ref, "height", bind("height", height_h95, w2_ref, w3_stacklayout_ref), height_h95, [w2_ref, w3_stacklayout_ref]]
if bound[0][5]:
prop = w3_stacklayout_get_prop("height")
dispatch_objs[5] = [w3_stacklayout, prop, prop.dispatch_count(w3_stacklayout)]
bound[1] = [None, None, None, w3_stacklayout_ref, "minimum_height", bind("minimum_height", height_h97, w3_stacklayout_ref), height_h97, (w3_stacklayout_ref, )]
if bound[1][5]:
prop = w3_stacklayout_get_prop("minimum_height")
dispatch_objs[6] = [w3_stacklayout, prop, prop.dispatch_count(w3_stacklayout)]
_handlers[w2.uid].append((bound, (0, )))
_handlers[w3_stacklayout.uid].append((bound, (1, )))
return partial(_d24, root_bound, w1_scrollview_bound, w3_stacklayout_bound, dispatch_objs, (w1_scrollview, w2, w3_stacklayout))
def _d24(root_bound, w1_scrollview_bound, w3_stacklayout_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
if dispatch_objs[5] is not None:
obj, prop, count = dispatch_objs[5]
prop.dispatch_stale(obj, count)
if dispatch_objs[6] is not None:
obj, prop, count = dispatch_objs[6]
prop.dispatch_stale(obj, count)
return widgets
def pos_h98(root, w1_layout, *args):
w1_layout.pos = root.pos
# <FileChooserIconView> L364
_mc[25] = set()
def _r25(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_layout = Factory.FileChooserIconLayout(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[25]:
if not hasattr(root, "layout"):
root.create_property("layout", (None))
w1_layout_create_property = w1_layout.create_property
if not hasattr(w1_layout, "controller"):
w1_layout_create_property("controller", (None))
if not hasattr(w1_layout, "pos"):
w1_layout_create_property("pos", (None))
_mc[25].add(root.__class__)
root.layout = w1_layout
w1_layout.controller = root
w1_layout.pos = root.pos
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b25(app, root, w1_layout))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b25, app, root, w1_layout))
def _b25(app, root, w1_layout):
root_ref = root.proxy_ref
w1_layout_ref = w1_layout.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "pos", root.fast_bind("pos", pos_h98, root_ref, w1_layout_ref), pos_h98, [root_ref, w1_layout_ref]]
if bound[0][5]:
prop = root.property("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
_handlers[w1_layout.uid].append((bound, (0, )))
return partial(_d25, root_bound, dispatch_objs, (w1_layout, ))
def _d25(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def text_h99(root, w1, *args):
w1.text = 'Opening %s' % root.path
def max_h100(root, w3_pb, *args):
w3_pb.max = root.total
def value_h101(root, w3_pb, *args):
w3_pb.value = root.index
def text_h102(root, w4, *args):
root = root.__self__
w4.text = '%d / %d' % (root.index, root.total)
def height_h103(w4, *args):
w4.height = w4.texture_size[1]
def y_h104(w3_pb, w4, *args):
w4.y = w3_pb.center_y - w4.height - 8
def pos_h105(g8, root, *args):
g8.pos = root.pos
def size_h106(g8, root, *args):
g8.size = root.size
def on_on_release_h12(root, *args):
root.cancel()
# <FileChooserProgress> L410
_mc[26] = set()
def _r26(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Label = Factory.Label
root_canvas_root_add = root.canvas.add
w1 = cls_Label(parent=root, __builder_created=bfuncs)
w2 = Factory.FloatLayout(parent=root, __builder_created=bfuncs)
w3_pb = Factory.ProgressBar(parent=w2, __builder_created=bfuncs)
w4 = cls_Label(parent=w2, __builder_created=bfuncs)
w5 = Factory.AnchorLayout(parent=root, __builder_created=bfuncs)
w6 = Factory.Button(parent=w5, __builder_created=bfuncs)
g7 = Factory.Color()
root_canvas_root_add(g7)
g8 = Factory.Rectangle()
root_canvas_root_add(g8)
if root.__class__ not in _mc[26]:
if not hasattr(root, "pos_hint"):
root.create_property("pos_hint", ({'x': 0, 'y': 0}))
w1_create_property = w1.create_property
if not hasattr(w1, "pos_hint"):
w1_create_property("pos_hint", ({'x': .2, 'y': .6}))
if not hasattr(w1, "size_hint"):
w1_create_property("size_hint", (.6, .2))
if not hasattr(w1, "text"):
w1_create_property("text", (None))
w2_create_property = w2.create_property
if not hasattr(w2, "pos_hint"):
w2_create_property("pos_hint", ({'x': .2, 'y': .4}))
if not hasattr(w2, "size_hint"):
w2_create_property("size_hint", (.6, .2))
w3_pb_create_property = w3_pb.create_property
if not hasattr(w3_pb, "pos_hint"):
w3_pb_create_property("pos_hint", ({'x': 0, 'center_y': .5}))
if not hasattr(w3_pb, "max"):
w3_pb_create_property("max", (None))
if not hasattr(w3_pb, "value"):
w3_pb_create_property("value", (None))
w4_create_property = w4.create_property
if not hasattr(w4, "pos_hint"):
w4_create_property("pos_hint", ({'x': 0}))
if not hasattr(w4, "text"):
w4_create_property("text", (None))
if not hasattr(w4, "size_hint_y"):
w4_create_property("size_hint_y", (None))
if not hasattr(w4, "height"):
w4_create_property("height", (None))
if not hasattr(w4, "y"):
w4_create_property("y", (None))
if not hasattr(w4, "font_size"):
w4_create_property("font_size", ('13sp'))
if not hasattr(w4, "color"):
w4_create_property("color", ((.8, .8, .8, .8)))
w5_create_property = w5.create_property
if not hasattr(w5, "pos_hint"):
w5_create_property("pos_hint", ({'x': .2, 'y': .2}))
if not hasattr(w5, "size_hint"):
w5_create_property("size_hint", (.6, .2))
w6_create_property = w6.create_property
if not hasattr(w6, "text"):
w6_create_property("text", ('Cancel'))
if not hasattr(w6, "size_hint"):
w6_create_property("size_hint", (None))
if not hasattr(w6, "size"):
w6_create_property("size", (150, 44))
_mc[26].add(root.__class__)
root.pos_hint = {'x': 0, 'y': 0}
w1.pos_hint = {'x': .2, 'y': .6}
w1.size_hint = .6, .2
w2.pos_hint = {'x': .2, 'y': .4}
w2.size_hint = .6, .2
w3_pb.pos_hint = {'x': 0, 'center_y': .5}
w4.pos_hint = {'x': 0}
w4.size_hint_y = None
w4.font_size = '13sp'
w4.color = (.8, .8, .8, .8)
w5.pos_hint = {'x': .2, 'y': .2}
w5.size_hint = .6, .2
w6.text = 'Cancel'
w6.size_hint = None, None
w6.size = 150, 44
g7.rgba = 0, 0, 0, .8
w1.text = 'Opening %s' % root.path
w3_pb.max = root.total
w3_pb.value = root.index
w4.text = '%d / %d' % (root.index, root.total)
w4.height = w4.texture_size[1]
w4.y = w3_pb.center_y - w4.height - 8
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b26(app, g7, g8, root, w1, w2, w3_pb, w4, w5, w6))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b26, app, g7, g8, root, w1, w2, w3_pb, w4, w5, w6))
def _b26(app, g7, g8, root, w1, w2, w3_pb, w4, w5, w6):
g8_ref = g8.proxy_ref
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w3_pb_ref = w3_pb.proxy_ref
w4_ref = w4.proxy_ref
delayed_pos_h105 = [pos_h105, g8_ref, root_ref, None]
delayed_call_fn(delayed_pos_h105, None, None)
delayed_size_h106 = [size_h106, g8_ref, root_ref, None]
delayed_call_fn(delayed_size_h106, None, None)
dispatch_objs = [None, ] * 2
root_bound = bound = [None, ] * 7
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "path", bind("path", text_h99, root_ref, w1_ref), text_h99, [root_ref, w1_ref]]
bound[1] = [None, None, None, root_ref, "total", bind("total", max_h100, root_ref, w3_pb_ref), max_h100, [root_ref, w3_pb_ref]]
bound[2] = [None, None, None, root_ref, "index", bind("index", value_h101, root_ref, w3_pb_ref), value_h101, [root_ref, w3_pb_ref]]
bound[3] = [None, None, None, root_ref, "index", bind("index", text_h102, root_ref, w4_ref), text_h102, [root_ref, w4_ref]]
bound[4] = [None, None, None, root_ref, "total", bind("total", text_h102, root_ref, w4_ref), text_h102, [root_ref, w4_ref]]
bound[5] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h105), delayed_call_fn, (delayed_pos_h105, )]
bound[6] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h106), delayed_call_fn, (delayed_size_h106, )]
_handlers[w3_pb.uid].append((bound, (1, 2)))
_handlers[w4.uid].append((bound, (3, 4)))
_handlers[w1.uid].append((bound, (0, )))
_handlers[g8.uid].append((bound, (5, 6)))
w3_pb_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w3_pb_ref, "center_y", w3_pb.fast_bind("center_y", y_h104, w3_pb_ref, w4_ref), y_h104, [w3_pb_ref, w4_ref]]
_handlers[w4.uid].append((bound, (0, )))
w4_bound = bound = [None, ] * 2
bind = w4.fast_bind
bound[0] = [None, None, None, w4_ref, "texture_size", bind("texture_size", height_h103, w4_ref), height_h103, (w4_ref, )]
if bound[0][5]:
prop = w4.property("texture_size")
dispatch_objs[0] = [w4, prop, prop.dispatch_count(w4)]
bound[1] = [None, None, None, w4_ref, "height", bind("height", y_h104, w3_pb_ref, w4_ref), y_h104, [w3_pb_ref, w4_ref]]
_handlers[w4.uid].append((bound, (0, 1)))
w6.fast_bind("on_release", on_on_release_h12, root_ref)
prop = w6.property("on_release", quiet=True)
if prop is not None:
dispatch_objs[1] = [w6, prop, prop.dispatch_count(w6)]
return partial(_d26, w3_pb_bound, w4_bound, root_bound, dispatch_objs, (w1, w2, w3_pb, w4, w5, w6))
def _d26(w3_pb_bound, w4_bound, root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
return widgets
def active_norm_pos_h107(root, *args):
root = root.__self__
root.active_norm_pos = max(0., min(1., (int(root.active) + root.touch_distance / sp(41))))
def source_h108(g2, root, *args):
g2.source = 'atlas://data/images/defaulttheme/switch-background{}'.format('_disabled' if root.disabled else '')
def pos_h109(g2, root, *args):
root = root.__self__
g2.pos = int(root.center_x - sp(41)), int(root.center_y - sp(16))
def source_h110(g3, root, *args):
g3.source = 'atlas://data/images/defaulttheme/switch-button{}'.format('_disabled' if root.disabled else '')
def pos_h111(g3, root, *args):
root = root.__self__
g3.pos = int(root.center_x - sp(41) + root.active_norm_pos * sp(41)), int(root.center_y - sp(16))
# <Switch> L452
_mc[27] = set()
def _r27(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Rectangle = Factory.Rectangle
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = cls_Rectangle()
root_canvas_root_add(g2)
g3 = cls_Rectangle()
root_canvas_root_add(g3)
if root.__class__ not in _mc[27]:
if not hasattr(root, "active_norm_pos"):
root.create_property("active_norm_pos", (None))
_mc[27].add(root.__class__)
g1.rgb = 1, 1, 1
g2.size = sp(83), sp(32)
g3.size = sp(43), sp(32)
root.active_norm_pos = max(0., min(1., (int(root.active) + root.touch_distance / sp(41))))
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b27(app, g1, g2, g3, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b27, app, g1, g2, g3, root))
def _b27(app, g1, g2, g3, root):
g2_ref = g2.proxy_ref
g3_ref = g3.proxy_ref
root_ref = root.proxy_ref
delayed_source_h108 = [source_h108, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h108, None, None)
delayed_pos_h109 = [pos_h109, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h109, None, None)
delayed_source_h110 = [source_h110, g3_ref, root_ref, None]
delayed_call_fn(delayed_source_h110, None, None)
delayed_pos_h111 = [pos_h111, g3_ref, root_ref, None]
delayed_call_fn(delayed_pos_h111, None, None)
root_bound = bound = [None, ] * 9
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "active", bind("active", active_norm_pos_h107, root_ref), active_norm_pos_h107, (root_ref, )]
bound[1] = [None, None, None, root_ref, "touch_distance", bind("touch_distance", active_norm_pos_h107, root_ref), active_norm_pos_h107, (root_ref, )]
bound[2] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_source_h108), delayed_call_fn, (delayed_source_h108, )]
bound[3] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h109), delayed_call_fn, (delayed_pos_h109, )]
bound[4] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h109), delayed_call_fn, (delayed_pos_h109, )]
bound[5] = [None, None, None, root_ref, "disabled", bind("disabled", delayed_call_fn, delayed_source_h110), delayed_call_fn, (delayed_source_h110, )]
bound[6] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h111), delayed_call_fn, (delayed_pos_h111, )]
bound[7] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h111), delayed_call_fn, (delayed_pos_h111, )]
bound[8] = [None, None, None, root_ref, "active_norm_pos", bind("active_norm_pos", delayed_call_fn, delayed_pos_h111), delayed_call_fn, (delayed_pos_h111, )]
_handlers[g3.uid].append((bound, (5, 6, 7, 8)))
_handlers[root.uid].append((bound, (0, 1)))
_handlers[g2.uid].append((bound, (2, 3, 4)))
return tuple
def rgba_h112(g1, root, *args):
root = root.__self__
g1.rgba = root.background_color[:3] + [root.background_color[-1] * root._anim_alpha]
def size_h113(g2, root, *args):
root = root.__self__
g2.size = root._window.size if root._window else (0, 0)
def source_h114(g4, root, *args):
g4.source = root.background
def border_h115(g4, root, *args):
g4.border = root.border
def pos_h116(g4, root, *args):
g4.pos = root.pos
def size_h117(g4, root, *args):
g4.size = root.size
# <ModalView> L468
def _r28(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Color = Factory.Color
root_canvas_root_add = root.canvas.add
g1 = cls_Color()
root_canvas_root_add(g1)
g2 = Factory.Rectangle()
root_canvas_root_add(g2)
g3 = cls_Color()
root_canvas_root_add(g3)
g4 = Factory.BorderImage()
root_canvas_root_add(g4)
g3.rgb = 1, 1, 1
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b28(app, g1, g2, g3, g4, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b28, app, g1, g2, g3, g4, root))
def _b28(app, g1, g2, g3, g4, root):
g4_ref = g4.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h112 = [rgba_h112, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h112, None, None)
delayed_size_h113 = [size_h113, g2.proxy_ref, root_ref, None]
delayed_call_fn(delayed_size_h113, None, None)
delayed_source_h114 = [source_h114, g4_ref, root_ref, None]
delayed_call_fn(delayed_source_h114, None, None)
delayed_border_h115 = [border_h115, g4_ref, root_ref, None]
delayed_call_fn(delayed_border_h115, None, None)
delayed_pos_h116 = [pos_h116, g4_ref, root_ref, None]
delayed_call_fn(delayed_pos_h116, None, None)
delayed_size_h117 = [size_h117, g4_ref, root_ref, None]
delayed_call_fn(delayed_size_h117, None, None)
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 9
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "_anim_alpha", bind("_anim_alpha", delayed_call_fn, delayed_rgba_h112), delayed_call_fn, (delayed_rgba_h112, )]
bound[1] = [None, None, None, root_ref, "background_color", bind("background_color", delayed_call_fn, delayed_rgba_h112), delayed_call_fn, (delayed_rgba_h112, )]
bound[2] = [None, None, None, root_ref, "_window", bind("_window", delayed_call_fn, delayed_size_h113), delayed_call_fn, (delayed_size_h113, )]
bound[3] = [None, None, None, root_ref, "background", bind("background", delayed_call_fn, delayed_source_h114), delayed_call_fn, (delayed_source_h114, )]
bound[4] = [None, None, None, root_ref, "border", bind("border", delayed_call_fn, delayed_border_h115), delayed_call_fn, (delayed_border_h115, )]
bound[5] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h116), delayed_call_fn, (delayed_pos_h116, )]
bound[6] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h117), delayed_call_fn, (delayed_size_h117, )]
if root.rebind_property("_window"):
bound[7] = [8, 9, None, root_ref, "_window", bind("_window", rebind_callback, bound, 7), rebind_callback, (bound, 7)]
if bound[7][5]:
prop = root.property("_window")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
else:
bound[7] = [8, 9, None, None, "_window", None, rebind_callback, (bound, 7)]
obj_root__window = root._window
if obj_root__window is not None and isinstance(obj_root__window, (EventDispatcher, Observable)):
bind = obj_root__window.fast_bind
bound[8] = [None, None, 7, obj_root__window.proxy_ref, "size", bind("size", delayed_call_fn, delayed_size_h113), delayed_call_fn, (delayed_size_h113, )]
if bound[7] is not None and bound[8] is None:
bound[8] = [None, None, 7, None, "size", None, delayed_call_fn, (delayed_size_h113, )]
_handlers[g4.uid].append((bound, (3, 4, 5, 6)))
_handlers[g2.uid].append((bound, (2, 8)))
_handlers[g1.uid].append((bound, (0, 1)))
return partial(_d28, root_bound, dispatch_objs, ())
def _d28(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def pos_h118(root, w1, *args):
w1.pos = root.pos
def size_h119(root, w1, *args):
w1.size = root.size
def text_h120(root, w2, *args):
w2.text = root.title
def color_h121(root, w2, *args):
w2.color = root.title_color
def height_h122(w2, *args):
w2.height = w2.texture_size[1] + dp(16)
def text_size_h123(w2, *args):
w2.text_size = w2.width - dp(16), None
def font_size_h124(root, w2, *args):
w2.font_size = root.title_size
def font_name_h125(root, w2, *args):
w2.font_name = root.title_font
def halign_h126(root, w2, *args):
w2.halign = root.title_align
def rgba_h127(g4, root, *args):
g4.rgba = root.separator_color
def pos_h128(g5, root, w3, *args):
w3 = w3.__self__
g5.pos = w3.x, w3.y + root.separator_height / 2.
def size_h129(g5, root, w3, *args):
g5.size = w3.width, root.separator_height
# <Popup> L485
_mc[29] = set()
def _r29(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.GridLayout(parent=root, __builder_created=bfuncs)
w2 = Factory.Label(parent=w1, __builder_created=bfuncs)
w3 = Factory.Widget(parent=w1, __builder_created=bfuncs)
w3_canvas_root_add = w3.canvas.add
g4 = Factory.Color()
w3_canvas_root_add(g4)
g5 = Factory.Rectangle()
w3_canvas_root_add(g5)
w6_container = Factory.BoxLayout(parent=w1, __builder_created=bfuncs)
if root.__class__ not in _mc[29]:
if not hasattr(root, "_container"):
root.create_property("_container", (None))
w1_create_property = w1.create_property
if not hasattr(w1, "padding"):
w1_create_property("padding", ('12dp'))
if not hasattr(w1, "cols"):
w1_create_property("cols", (1))
if not hasattr(w1, "size_hint"):
w1_create_property("size_hint", (None))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "size"):
w1_create_property("size", (None))
w2_create_property = w2.create_property
if not hasattr(w2, "text"):
w2_create_property("text", (None))
if not hasattr(w2, "color"):
w2_create_property("color", (None))
if not hasattr(w2, "size_hint_y"):
w2_create_property("size_hint_y", (None))
if not hasattr(w2, "height"):
w2_create_property("height", (None))
if not hasattr(w2, "text_size"):
w2_create_property("text_size", (None))
if not hasattr(w2, "font_size"):
w2_create_property("font_size", (None))
if not hasattr(w2, "font_name"):
w2_create_property("font_name", (None))
if not hasattr(w2, "halign"):
w2_create_property("halign", (None))
w3_create_property = w3.create_property
if not hasattr(w3, "size_hint_y"):
w3_create_property("size_hint_y", (None))
if not hasattr(w3, "height"):
w3_create_property("height", (None))
_mc[29].add(root.__class__)
root._container = w6_container
w1.padding = '12dp'
w1.cols = 1
w1.size_hint = None, None
w2.size_hint_y = None
w3.size_hint_y = None
w3.height = dp(4)
w1.pos = root.pos
w1.size = root.size
w2.text = root.title
w2.color = root.title_color
w2.height = w2.texture_size[1] + dp(16)
w2.text_size = w2.width - dp(16), None
w2.font_size = root.title_size
w2.font_name = root.title_font
w2.halign = root.title_align
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b29(app, g4, g5, root, w1, w2, w3, w6_container))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b29, app, g4, g5, root, w1, w2, w3, w6_container))
def _b29(app, g4, g5, root, w1, w2, w3, w6_container):
g5_ref = g5.proxy_ref
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w2_ref = w2.proxy_ref
w3_ref = w3.proxy_ref
delayed_rgba_h127 = [rgba_h127, g4.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h127, None, None)
delayed_pos_h128 = [pos_h128, g5_ref, root_ref, w3_ref, None]
delayed_call_fn(delayed_pos_h128, None, None)
delayed_size_h129 = [size_h129, g5_ref, root_ref, w3_ref, None]
delayed_call_fn(delayed_size_h129, None, None)
dispatch_objs = [None, ] * 3
root_bound = bound = [None, ] * 10
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h118, root_ref, w1_ref), pos_h118, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "size", bind("size", size_h119, root_ref, w1_ref), size_h119, [root_ref, w1_ref]]
if bound[1][5]:
prop = root_get_prop("size")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "title", bind("title", text_h120, root_ref, w2_ref), text_h120, [root_ref, w2_ref]]
bound[3] = [None, None, None, root_ref, "title_color", bind("title_color", color_h121, root_ref, w2_ref), color_h121, [root_ref, w2_ref]]
bound[4] = [None, None, None, root_ref, "title_size", bind("title_size", font_size_h124, root_ref, w2_ref), font_size_h124, [root_ref, w2_ref]]
bound[5] = [None, None, None, root_ref, "title_font", bind("title_font", font_name_h125, root_ref, w2_ref), font_name_h125, [root_ref, w2_ref]]
bound[6] = [None, None, None, root_ref, "title_align", bind("title_align", halign_h126, root_ref, w2_ref), halign_h126, [root_ref, w2_ref]]
bound[7] = [None, None, None, root_ref, "separator_color", bind("separator_color", delayed_call_fn, delayed_rgba_h127), delayed_call_fn, (delayed_rgba_h127, )]
bound[8] = [None, None, None, root_ref, "separator_height", bind("separator_height", delayed_call_fn, delayed_pos_h128), delayed_call_fn, (delayed_pos_h128, )]
if bound[8][5]:
prop = root_get_prop("separator_height")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[9] = [None, None, None, root_ref, "separator_height", bind("separator_height", delayed_call_fn, delayed_size_h129), delayed_call_fn, (delayed_size_h129, )]
_handlers[g5.uid].append((bound, (8, 9)))
_handlers[g4.uid].append((bound, (7, )))
_handlers[w2.uid].append((bound, (2, 3, 4, 5, 6)))
_handlers[w1.uid].append((bound, (0, 1)))
w2_bound = bound = [None, ] * 2
bind = w2.fast_bind
bound[0] = [None, None, None, w2_ref, "texture_size", bind("texture_size", height_h122, w2_ref), height_h122, (w2_ref, )]
bound[1] = [None, None, None, w2_ref, "width", bind("width", text_size_h123, w2_ref), text_size_h123, (w2_ref, )]
_handlers[w2.uid].append((bound, (0, 1)))
w3_bound = bound = [None, ] * 3
bind = w3.fast_bind
bound[0] = [None, None, None, w3_ref, "x", bind("x", delayed_call_fn, delayed_pos_h128), delayed_call_fn, (delayed_pos_h128, )]
bound[1] = [None, None, None, w3_ref, "y", bind("y", delayed_call_fn, delayed_pos_h128), delayed_call_fn, (delayed_pos_h128, )]
bound[2] = [None, None, None, w3_ref, "width", bind("width", delayed_call_fn, delayed_size_h129), delayed_call_fn, (delayed_size_h129, )]
_handlers[g5.uid].append((bound, (0, 1, 2)))
return partial(_d29, w3_bound, root_bound, w2_bound, dispatch_objs, (w1, w2, w3, w6_container))
def _d29(w3_bound, root_bound, w2_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
return widgets
# <SpinnerOption> L521
_mc[30] = set()
def _r30(root, builder_created):
if root.__class__ not in _mc[30]:
root_create_property = root.create_property
if not hasattr(root, "size_hint_y"):
root_create_property("size_hint_y", (None))
if not hasattr(root, "height"):
root_create_property("height", ('48dp'))
_mc[30].add(root.__class__)
root.size_hint_y = None
root.height = '48dp'
# <Spinner> L525
_mc[31] = set()
def _r31(root, builder_created):
if root.__class__ not in _mc[31]:
root_create_property = root.create_property
if not hasattr(root, "background_normal"):
root_create_property("background_normal", ('atlas://data/images/defaulttheme/spinner'))
if not hasattr(root, "background_disabled_normal"):
root_create_property("background_disabled_normal", ('atlas://data/images/defaulttheme/spinner_disabled'))
if not hasattr(root, "background_down"):
root_create_property("background_down", ('atlas://data/images/defaulttheme/spinner_pressed'))
_mc[31].add(root.__class__)
root.background_normal = 'atlas://data/images/defaulttheme/spinner'
root.background_disabled_normal = 'atlas://data/images/defaulttheme/spinner_disabled'
root.background_down = 'atlas://data/images/defaulttheme/spinner_pressed'
def rgba_h130(g1, root, *args):
g1.rgba = root.background_color
def border_h131(g2, root, *args):
g2.border = root.border
def pos_h132(g2, root, *args):
g2.pos = root.pos
def size_h133(g2, root, *args):
g2.size = root.size
def source_h134(g2, root, *args):
g2.source = root.background_image
# <ActionBar> L534
_mc[32] = set()
def _r32(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.BorderImage()
root_canvas_root_add(g2)
if root.__class__ not in _mc[32]:
root_create_property = root.create_property
if not hasattr(root, "height"):
root_create_property("height", ('48dp'))
if not hasattr(root, "size_hint_y"):
root_create_property("size_hint_y", (None))
if not hasattr(root, "spacing"):
root_create_property("spacing", ('4dp'))
_mc[32].add(root.__class__)
root.height = '48dp'
root.size_hint_y = None
root.spacing = '4dp'
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b32(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b32, app, g1, g2, root))
def _b32(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h130 = [rgba_h130, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h130, None, None)
delayed_border_h131 = [border_h131, g2_ref, root_ref, None]
delayed_call_fn(delayed_border_h131, None, None)
delayed_pos_h132 = [pos_h132, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h132, None, None)
delayed_size_h133 = [size_h133, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h133, None, None)
delayed_source_h134 = [source_h134, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h134, None, None)
root_bound = bound = [None, ] * 5
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "background_color", bind("background_color", delayed_call_fn, delayed_rgba_h130), delayed_call_fn, (delayed_rgba_h130, )]
bound[1] = [None, None, None, root_ref, "border", bind("border", delayed_call_fn, delayed_border_h131), delayed_call_fn, (delayed_border_h131, )]
bound[2] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h132), delayed_call_fn, (delayed_pos_h132, )]
bound[3] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h133), delayed_call_fn, (delayed_size_h133, )]
bound[4] = [None, None, None, root_ref, "background_image", bind("background_image", delayed_call_fn, delayed_source_h134), delayed_call_fn, (delayed_source_h134, )]
_handlers[g2.uid].append((bound, (1, 2, 3, 4)))
_handlers[g1.uid].append((bound, (0, )))
return tuple
def rgba_h135(g1, root, *args):
g1.rgba = root.background_color
def pos_h136(g2, root, *args):
g2.pos = root.pos
def size_h137(g2, root, *args):
g2.size = root.size
def source_h138(g2, root, *args):
g2.source = root.background_image
# <ActionView> L547
_mc[33] = set()
def _r33(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.BorderImage()
root_canvas_root_add(g2)
if root.__class__ not in _mc[33]:
if not hasattr(root, "orientation"):
root.create_property("orientation", ('horizontal'))
_mc[33].add(root.__class__)
root.orientation = 'horizontal'
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b33(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b33, app, g1, g2, root))
def _b33(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h135 = [rgba_h135, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h135, None, None)
delayed_pos_h136 = [pos_h136, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h136, None, None)
delayed_size_h137 = [size_h137, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h137, None, None)
delayed_source_h138 = [source_h138, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h138, None, None)
root_bound = bound = [None, ] * 4
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "background_color", bind("background_color", delayed_call_fn, delayed_rgba_h135), delayed_call_fn, (delayed_rgba_h135, )]
bound[1] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h136), delayed_call_fn, (delayed_pos_h136, )]
bound[2] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h137), delayed_call_fn, (delayed_size_h137, )]
bound[3] = [None, None, None, root_ref, "background_image", bind("background_image", delayed_call_fn, delayed_source_h138), delayed_call_fn, (delayed_source_h138, )]
_handlers[g2.uid].append((bound, (1, 2, 3)))
_handlers[g1.uid].append((bound, (0, )))
return tuple
def width_h139(root, *args):
root.width = root.minimum_width
def pos_h140(g1, root, *args):
root = root.__self__
g1.pos = root.x, root.y + sp(4)
def size_h141(g1, root, *args):
root = root.__self__
g1.size = root.width, root.height - sp(8)
def source_h142(g1, root, *args):
g1.source = root.background_image
# <ActionSeparator> L557
_mc[34] = set()
def _r34(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
g1 = Factory.Rectangle()
root.canvas.add(g1)
if root.__class__ not in _mc[34]:
root_create_property = root.create_property
if not hasattr(root, "size_hint_x"):
root_create_property("size_hint_x", (None))
if not hasattr(root, "minimum_width"):
root_create_property("minimum_width", ('2sp'))
if not hasattr(root, "width"):
root_create_property("width", (None))
_mc[34].add(root.__class__)
root.size_hint_x = None
root.minimum_width = '2sp'
root.width = root.minimum_width
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b34(app, g1, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b34, app, g1, root))
def _b34(app, g1, root):
g1_ref = g1.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h140 = [pos_h140, g1_ref, root_ref, None]
delayed_call_fn(delayed_pos_h140, None, None)
delayed_size_h141 = [size_h141, g1_ref, root_ref, None]
delayed_call_fn(delayed_size_h141, None, None)
delayed_source_h142 = [source_h142, g1_ref, root_ref, None]
delayed_call_fn(delayed_source_h142, None, None)
root_bound = bound = [None, ] * 6
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "minimum_width", bind("minimum_width", width_h139, root_ref), width_h139, (root_ref, )]
bound[1] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h140), delayed_call_fn, (delayed_pos_h140, )]
bound[2] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h140), delayed_call_fn, (delayed_pos_h140, )]
bound[3] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h141), delayed_call_fn, (delayed_size_h141, )]
bound[4] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_size_h141), delayed_call_fn, (delayed_size_h141, )]
bound[5] = [None, None, None, root_ref, "background_image", bind("background_image", delayed_call_fn, delayed_source_h142), delayed_call_fn, (delayed_source_h142, )]
_handlers[root.uid].append((bound, (0, )))
_handlers[g1.uid].append((bound, (1, 2, 3, 4, 5)))
return tuple
def background_normal_h143(root, *args):
root.background_normal = 'atlas://data/images/defaulttheme/' + ('action_bar' if root.inside_group else 'action_item')
def size_hint_x_h144(root, *args):
root.size_hint_x = None if not root.inside_group else 1
def width_h145(root, *args):
root = root.__self__
root.width = [dp(48) if (root.icon and not root.inside_group) else max(dp(48), (root.texture_size[0] + dp(32))), root.size_hint_x][0]
def color_h146(root, *args):
root = root.__self__
root.color = root.color[:3] + [0 if (root.icon and not root.inside_group) else 1]
def opacity_h147(root, w1, *args):
root = root.__self__
w1.opacity = 1 if (root.icon and not root.inside_group) else 0
def source_h148(root, w1, *args):
w1.source = root.icon
def mipmap_h149(root, w1, *args):
w1.mipmap = root.mipmap
def pos_h150(root, w1, *args):
root = root.__self__
w1.pos = root.x + dp(4), root.y + dp(4)
def size_h151(root, w1, *args):
root = root.__self__
w1.size = root.width - dp(8), root.height - sp(8)
# <ActionButton,ActionToggleButton> L567
_mc[35] = set()
def _r35(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.Image(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[35]:
root_create_property = root.create_property
if not hasattr(root, "background_normal"):
root_create_property("background_normal", (None))
if not hasattr(root, "background_down"):
root_create_property("background_down", ('atlas://data/images/defaulttheme/action_item_down'))
if not hasattr(root, "size_hint_x"):
root_create_property("size_hint_x", (None))
if not hasattr(root, "width"):
root_create_property("width", (None))
if not hasattr(root, "color"):
root_create_property("color", (None))
w1_create_property = w1.create_property
if not hasattr(w1, "allow_stretch"):
w1_create_property("allow_stretch", (None))
if not hasattr(w1, "opacity"):
w1_create_property("opacity", (None))
if not hasattr(w1, "source"):
w1_create_property("source", (None))
if not hasattr(w1, "mipmap"):
w1_create_property("mipmap", (None))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "size"):
w1_create_property("size", (None))
_mc[35].add(root.__class__)
root.background_down = 'atlas://data/images/defaulttheme/action_item_down'
w1.allow_stretch = True
root.background_normal = 'atlas://data/images/defaulttheme/' + ('action_bar' if root.inside_group else 'action_item')
root.size_hint_x = None if not root.inside_group else 1
root.width = [dp(48) if (root.icon and not root.inside_group) else max(dp(48), (root.texture_size[0] + dp(32))), root.size_hint_x][0]
root.color = root.color[:3] + [0 if (root.icon and not root.inside_group) else 1]
w1.opacity = 1 if (root.icon and not root.inside_group) else 0
w1.source = root.icon
w1.mipmap = root.mipmap
w1.pos = root.x + dp(4), root.y + dp(4)
w1.size = root.width - dp(8), root.height - sp(8)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b35(app, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b35, app, root, w1))
def _b35(app, root, w1):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
dispatch_objs = [None, ] * 6
root_bound = bound = [None, ] * 17
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "inside_group", bind("inside_group", background_normal_h143, root_ref), background_normal_h143, (root_ref, )]
bound[1] = [None, None, None, root_ref, "inside_group", bind("inside_group", size_hint_x_h144, root_ref), size_hint_x_h144, (root_ref, )]
if bound[1][5]:
prop = root_get_prop("inside_group")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "size_hint_x", bind("size_hint_x", width_h145, root_ref), width_h145, (root_ref, )]
if bound[2][5]:
prop = root_get_prop("size_hint_x")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[3] = [None, None, None, root_ref, "texture_size", bind("texture_size", width_h145, root_ref), width_h145, (root_ref, )]
if bound[3][5]:
prop = root_get_prop("texture_size")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[4] = [None, None, None, root_ref, "icon", bind("icon", width_h145, root_ref), width_h145, (root_ref, )]
if bound[4][5]:
prop = root_get_prop("icon")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
bound[5] = [None, None, None, root_ref, "inside_group", bind("inside_group", width_h145, root_ref), width_h145, (root_ref, )]
bound[6] = [None, None, None, root_ref, "color", bind("color", color_h146, root_ref), color_h146, (root_ref, )]
if bound[6][5]:
prop = root_get_prop("color")
dispatch_objs[4] = [root, prop, prop.dispatch_count(root)]
bound[7] = [None, None, None, root_ref, "icon", bind("icon", color_h146, root_ref), color_h146, (root_ref, )]
bound[8] = [None, None, None, root_ref, "inside_group", bind("inside_group", color_h146, root_ref), color_h146, (root_ref, )]
bound[9] = [None, None, None, root_ref, "icon", bind("icon", opacity_h147, root_ref, w1_ref), opacity_h147, [root_ref, w1_ref]]
bound[10] = [None, None, None, root_ref, "inside_group", bind("inside_group", opacity_h147, root_ref, w1_ref), opacity_h147, [root_ref, w1_ref]]
bound[11] = [None, None, None, root_ref, "icon", bind("icon", source_h148, root_ref, w1_ref), source_h148, [root_ref, w1_ref]]
bound[12] = [None, None, None, root_ref, "mipmap", bind("mipmap", mipmap_h149, root_ref, w1_ref), mipmap_h149, [root_ref, w1_ref]]
if bound[12][5]:
prop = root_get_prop("mipmap")
dispatch_objs[5] = [root, prop, prop.dispatch_count(root)]
bound[13] = [None, None, None, root_ref, "x", bind("x", pos_h150, root_ref, w1_ref), pos_h150, [root_ref, w1_ref]]
bound[14] = [None, None, None, root_ref, "y", bind("y", pos_h150, root_ref, w1_ref), pos_h150, [root_ref, w1_ref]]
bound[15] = [None, None, None, root_ref, "width", bind("width", size_h151, root_ref, w1_ref), size_h151, [root_ref, w1_ref]]
bound[16] = [None, None, None, root_ref, "height", bind("height", size_h151, root_ref, w1_ref), size_h151, [root_ref, w1_ref]]
_handlers[root.uid].append((bound, (0, 1, 2, 3, 4, 5, 6, 7, 8)))
_handlers[w1.uid].append((bound, (9, 10, 11, 12, 13, 14, 15, 16)))
return partial(_d35, root_bound, dispatch_objs, (w1, ))
def _d35(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
if dispatch_objs[5] is not None:
obj, prop, count = dispatch_objs[5]
prop.dispatch_stale(obj, count)
return widgets
def width_h152(root, *args):
root.width = root.texture_size[0] + dp(32)
# <ActionGroup> L582
_mc[36] = set()
def _r36(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
if root.__class__ not in _mc[36]:
root_create_property = root.create_property
if not hasattr(root, "size_hint_x"):
root_create_property("size_hint_x", (None))
if not hasattr(root, "width"):
root_create_property("width", (None))
_mc[36].add(root.__class__)
root.size_hint_x = None
root.width = root.texture_size[0] + dp(32)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b36(app, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b36, app, root))
def _b36(app, root):
root_ref = root.proxy_ref
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "texture_size", root.fast_bind("texture_size", width_h152, root_ref), width_h152, (root_ref, )]
_handlers[root.uid].append((bound, (0, )))
return tuple
def background_normal_h153(root, *args):
root.background_normal = 'atlas://data/images/defaulttheme/action_bar' if root.inside_group else 'atlas://data/images/defaulttheme/action_item'
# <ActionCheck> L586
_mc[37] = set()
def _r37(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
if root.__class__ not in _mc[37]:
if not hasattr(root, "background_normal"):
root.create_property("background_normal", (None))
_mc[37].add(root.__class__)
root.background_normal = 'atlas://data/images/defaulttheme/action_bar' if root.inside_group else 'atlas://data/images/defaulttheme/action_item'
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b37(app, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b37, app, root))
def _b37(app, root):
root_ref = root.proxy_ref
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "inside_group", root.fast_bind("inside_group", background_normal_h153, root_ref), background_normal_h153, (root_ref, )]
_handlers[root.uid].append((bound, (0, )))
return tuple
# <ActionPreviousImage@Image> L589
_mc[38] = set()
def _r38(root, builder_created):
if root.__class__ not in _mc[38]:
root_create_property = root.create_property
if not hasattr(root, "temp_width"):
root_create_property("temp_width", (0))
if not hasattr(root, "temp_height"):
root_create_property("temp_height", (0))
_mc[38].add(root.__class__)
root.temp_width = 0
root.temp_height = 0
def pos_h154(root, w1, *args):
w1.pos = root.pos
def size_h155(root, w1, *args):
w1.size = root.size
def source_h156(root, w2_prev_icon_image, *args):
w2_prev_icon_image.source = root.previous_image
def opacity_h157(root, w2_prev_icon_image, *args):
w2_prev_icon_image.opacity = 1 if root.with_previous else 0
def temp_width_h158(root, w2_prev_icon_image, *args):
w2_prev_icon_image.temp_width = root.previous_image_width or dp(w2_prev_icon_image.texture_size[0])
def temp_height_h159(root, w2_prev_icon_image, *args):
w2_prev_icon_image.temp_height = root.previous_image_height or dp(w2_prev_icon_image.texture_size[1])
def width_h160(w2_prev_icon_image, *args):
w2_prev_icon_image = w2_prev_icon_image.__self__
w2_prev_icon_image.width = (w2_prev_icon_image.temp_width if w2_prev_icon_image.temp_height <= w2_prev_icon_image.height else \
w2_prev_icon_image.temp_width * (w2_prev_icon_image.height / w2_prev_icon_image.temp_height)) \
if w2_prev_icon_image.texture else dp(8)
def mipmap_h161(root, w2_prev_icon_image, *args):
w2_prev_icon_image.mipmap = root.mipmap
def source_h162(root, w3_app_icon_image, *args):
w3_app_icon_image.source = root.app_icon
def temp_width_h163(root, w3_app_icon_image, *args):
w3_app_icon_image.temp_width = root.app_icon_width or dp(w3_app_icon_image.texture_size[0])
def temp_height_h164(root, w3_app_icon_image, *args):
w3_app_icon_image.temp_height = root.app_icon_height or dp(w3_app_icon_image.texture_size[1])
def width_h165(w3_app_icon_image, *args):
w3_app_icon_image = w3_app_icon_image.__self__
w3_app_icon_image.width = (w3_app_icon_image.temp_width if w3_app_icon_image.temp_height <= w3_app_icon_image.height else \
w3_app_icon_image.temp_width * (w3_app_icon_image.height / w3_app_icon_image.temp_height)) \
if w3_app_icon_image.texture else dp(8)
def mipmap_h166(root, w3_app_icon_image, *args):
w3_app_icon_image.mipmap = root.mipmap
def text_h167(root, w5, *args):
w5.text = root.title
def text_size_h168(w5, *args):
w5.text_size = w5.size
def color_h169(root, w5, *args):
w5.color = root.color
# <ActionPrevious> L593
_mc[39] = set()
def _r39(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_ActionPreviousImage = Factory.ActionPreviousImage
w1 = Factory.BoxLayout(parent=root, __builder_created=bfuncs)
w2_prev_icon_image = cls_ActionPreviousImage(parent=w1, __builder_created=bfuncs)
w3_app_icon_image = cls_ActionPreviousImage(parent=w1, __builder_created=bfuncs)
w4 = Factory.Widget(parent=w1, __builder_created=bfuncs)
w5 = Factory.Label(parent=w1, __builder_created=bfuncs)
if root.__class__ not in _mc[39]:
root_create_property = root.create_property
if not hasattr(root, "size_hint_x"):
root_create_property("size_hint_x", (1))
if not hasattr(root, "minimum_width"):
root_create_property("minimum_width", ('100sp'))
if not hasattr(root, "important"):
root_create_property("important", (None))
w1_create_property = w1.create_property
if not hasattr(w1, "orientation"):
w1_create_property("orientation", ('horizontal'))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "size"):
w1_create_property("size", (None))
w2_prev_icon_image_create_property = w2_prev_icon_image.create_property
if not hasattr(w2_prev_icon_image, "source"):
w2_prev_icon_image_create_property("source", (None))
if not hasattr(w2_prev_icon_image, "opacity"):
w2_prev_icon_image_create_property("opacity", (None))
if not hasattr(w2_prev_icon_image, "allow_stretch"):
w2_prev_icon_image_create_property("allow_stretch", (None))
if not hasattr(w2_prev_icon_image, "size_hint_x"):
w2_prev_icon_image_create_property("size_hint_x", (None))
if not hasattr(w2_prev_icon_image, "temp_width"):
w2_prev_icon_image_create_property("temp_width", (None))
if not hasattr(w2_prev_icon_image, "temp_height"):
w2_prev_icon_image_create_property("temp_height", (None))
if not hasattr(w2_prev_icon_image, "width"):
w2_prev_icon_image_create_property("width", (None))
if not hasattr(w2_prev_icon_image, "mipmap"):
w2_prev_icon_image_create_property("mipmap", (None))
w3_app_icon_image_create_property = w3_app_icon_image.create_property
if not hasattr(w3_app_icon_image, "source"):
w3_app_icon_image_create_property("source", (None))
if not hasattr(w3_app_icon_image, "allow_stretch"):
w3_app_icon_image_create_property("allow_stretch", (None))
if not hasattr(w3_app_icon_image, "size_hint_x"):
w3_app_icon_image_create_property("size_hint_x", (None))
if not hasattr(w3_app_icon_image, "temp_width"):
w3_app_icon_image_create_property("temp_width", (None))
if not hasattr(w3_app_icon_image, "temp_height"):
w3_app_icon_image_create_property("temp_height", (None))
if not hasattr(w3_app_icon_image, "width"):
w3_app_icon_image_create_property("width", (None))
if not hasattr(w3_app_icon_image, "mipmap"):
w3_app_icon_image_create_property("mipmap", (None))
w4_create_property = w4.create_property
if not hasattr(w4, "size_hint_x"):
w4_create_property("size_hint_x", (None))
if not hasattr(w4, "width"):
w4_create_property("width", ('5sp'))
w5_create_property = w5.create_property
if not hasattr(w5, "text"):
w5_create_property("text", (None))
if not hasattr(w5, "text_size"):
w5_create_property("text_size", (None))
if not hasattr(w5, "color"):
w5_create_property("color", (None))
if not hasattr(w5, "shorten"):
w5_create_property("shorten", (None))
if not hasattr(w5, "halign"):
w5_create_property("halign", ('left'))
if not hasattr(w5, "valign"):
w5_create_property("valign", ('middle'))
_mc[39].add(root.__class__)
root.size_hint_x = 1
root.minimum_width = '100sp'
root.important = True
w1.orientation = 'horizontal'
w2_prev_icon_image.allow_stretch = True
w2_prev_icon_image.size_hint_x = None
w3_app_icon_image.allow_stretch = True
w3_app_icon_image.size_hint_x = None
w4.size_hint_x = None
w4.width = '5sp'
w5.shorten = True
w5.halign = 'left'
w5.valign = 'middle'
w1.pos = root.pos
w1.size = root.size
w2_prev_icon_image.source = root.previous_image
w2_prev_icon_image.opacity = 1 if root.with_previous else 0
w2_prev_icon_image.temp_width = root.previous_image_width or dp(w2_prev_icon_image.texture_size[0])
w2_prev_icon_image.temp_height = root.previous_image_height or dp(w2_prev_icon_image.texture_size[1])
w2_prev_icon_image.width = (w2_prev_icon_image.temp_width if w2_prev_icon_image.temp_height <= w2_prev_icon_image.height else \
w2_prev_icon_image.temp_width * (w2_prev_icon_image.height / w2_prev_icon_image.temp_height)) \
if w2_prev_icon_image.texture else dp(8)
w2_prev_icon_image.mipmap = root.mipmap
w3_app_icon_image.source = root.app_icon
w3_app_icon_image.temp_width = root.app_icon_width or dp(w3_app_icon_image.texture_size[0])
w3_app_icon_image.temp_height = root.app_icon_height or dp(w3_app_icon_image.texture_size[1])
w3_app_icon_image.width = (w3_app_icon_image.temp_width if w3_app_icon_image.temp_height <= w3_app_icon_image.height else \
w3_app_icon_image.temp_width * (w3_app_icon_image.height / w3_app_icon_image.temp_height)) \
if w3_app_icon_image.texture else dp(8)
w3_app_icon_image.mipmap = root.mipmap
w5.text = root.title
w5.text_size = w5.size
w5.color = root.color
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b39(app, root, w1, w2_prev_icon_image, w3_app_icon_image, w4, w5))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b39, app, root, w1, w2_prev_icon_image, w3_app_icon_image, w4, w5))
def _b39(app, root, w1, w2_prev_icon_image, w3_app_icon_image, w4, w5):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w2_prev_icon_image_ref = w2_prev_icon_image.proxy_ref
w3_app_icon_image_ref = w3_app_icon_image.proxy_ref
w5_ref = w5.proxy_ref
dispatch_objs = [None, ] * 6
root_bound = bound = [None, ] * 13
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h154, root_ref, w1_ref), pos_h154, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "size", bind("size", size_h155, root_ref, w1_ref), size_h155, [root_ref, w1_ref]]
if bound[1][5]:
prop = root_get_prop("size")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "previous_image", bind("previous_image", source_h156, root_ref, w2_prev_icon_image_ref), source_h156, [root_ref, w2_prev_icon_image_ref]]
bound[3] = [None, None, None, root_ref, "with_previous", bind("with_previous", opacity_h157, root_ref, w2_prev_icon_image_ref), opacity_h157, [root_ref, w2_prev_icon_image_ref]]
bound[4] = [None, None, None, root_ref, "previous_image_width", bind("previous_image_width", temp_width_h158, root_ref, w2_prev_icon_image_ref), temp_width_h158, [root_ref, w2_prev_icon_image_ref]]
bound[5] = [None, None, None, root_ref, "previous_image_height", bind("previous_image_height", temp_height_h159, root_ref, w2_prev_icon_image_ref), temp_height_h159, [root_ref, w2_prev_icon_image_ref]]
bound[6] = [None, None, None, root_ref, "mipmap", bind("mipmap", mipmap_h161, root_ref, w2_prev_icon_image_ref), mipmap_h161, [root_ref, w2_prev_icon_image_ref]]
if bound[6][5]:
prop = root_get_prop("mipmap")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[7] = [None, None, None, root_ref, "app_icon", bind("app_icon", source_h162, root_ref, w3_app_icon_image_ref), source_h162, [root_ref, w3_app_icon_image_ref]]
bound[8] = [None, None, None, root_ref, "app_icon_width", bind("app_icon_width", temp_width_h163, root_ref, w3_app_icon_image_ref), temp_width_h163, [root_ref, w3_app_icon_image_ref]]
bound[9] = [None, None, None, root_ref, "app_icon_height", bind("app_icon_height", temp_height_h164, root_ref, w3_app_icon_image_ref), temp_height_h164, [root_ref, w3_app_icon_image_ref]]
bound[10] = [None, None, None, root_ref, "mipmap", bind("mipmap", mipmap_h166, root_ref, w3_app_icon_image_ref), mipmap_h166, [root_ref, w3_app_icon_image_ref]]
bound[11] = [None, None, None, root_ref, "title", bind("title", text_h167, root_ref, w5_ref), text_h167, [root_ref, w5_ref]]
bound[12] = [None, None, None, root_ref, "color", bind("color", color_h169, root_ref, w5_ref), color_h169, [root_ref, w5_ref]]
if bound[12][5]:
prop = root_get_prop("color")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
_handlers[w3_app_icon_image.uid].append((bound, (7, 8, 9, 10)))
_handlers[w5.uid].append((bound, (11, 12)))
_handlers[w2_prev_icon_image.uid].append((bound, (2, 3, 4, 5, 6)))
_handlers[w1.uid].append((bound, (0, 1)))
w2_prev_icon_image_bound = bound = [None, ] * 6
bind = w2_prev_icon_image.fast_bind
bound[0] = [None, None, None, w2_prev_icon_image_ref, "texture_size", bind("texture_size", temp_width_h158, root_ref, w2_prev_icon_image_ref), temp_width_h158, [root_ref, w2_prev_icon_image_ref]]
if bound[0][5]:
prop = w2_prev_icon_image.property("texture_size")
dispatch_objs[4] = [w2_prev_icon_image, prop, prop.dispatch_count(w2_prev_icon_image)]
bound[1] = [None, None, None, w2_prev_icon_image_ref, "texture_size", bind("texture_size", temp_height_h159, root_ref, w2_prev_icon_image_ref), temp_height_h159, [root_ref, w2_prev_icon_image_ref]]
bound[2] = [None, None, None, w2_prev_icon_image_ref, "temp_height", bind("temp_height", width_h160, w2_prev_icon_image_ref), width_h160, (w2_prev_icon_image_ref, )]
bound[3] = [None, None, None, w2_prev_icon_image_ref, "texture", bind("texture", width_h160, w2_prev_icon_image_ref), width_h160, (w2_prev_icon_image_ref, )]
bound[4] = [None, None, None, w2_prev_icon_image_ref, "temp_width", bind("temp_width", width_h160, w2_prev_icon_image_ref), width_h160, (w2_prev_icon_image_ref, )]
bound[5] = [None, None, None, w2_prev_icon_image_ref, "height", bind("height", width_h160, w2_prev_icon_image_ref), width_h160, (w2_prev_icon_image_ref, )]
_handlers[w2_prev_icon_image.uid].append((bound, (0, 1, 2, 3, 4, 5)))
w3_app_icon_image_bound = bound = [None, ] * 6
bind = w3_app_icon_image.fast_bind
bound[0] = [None, None, None, w3_app_icon_image_ref, "texture_size", bind("texture_size", temp_width_h163, root_ref, w3_app_icon_image_ref), temp_width_h163, [root_ref, w3_app_icon_image_ref]]
if bound[0][5]:
prop = w3_app_icon_image.property("texture_size")
dispatch_objs[5] = [w3_app_icon_image, prop, prop.dispatch_count(w3_app_icon_image)]
bound[1] = [None, None, None, w3_app_icon_image_ref, "texture_size", bind("texture_size", temp_height_h164, root_ref, w3_app_icon_image_ref), temp_height_h164, [root_ref, w3_app_icon_image_ref]]
bound[2] = [None, None, None, w3_app_icon_image_ref, "temp_height", bind("temp_height", width_h165, w3_app_icon_image_ref), width_h165, (w3_app_icon_image_ref, )]
bound[3] = [None, None, None, w3_app_icon_image_ref, "texture", bind("texture", width_h165, w3_app_icon_image_ref), width_h165, (w3_app_icon_image_ref, )]
bound[4] = [None, None, None, w3_app_icon_image_ref, "temp_width", bind("temp_width", width_h165, w3_app_icon_image_ref), width_h165, (w3_app_icon_image_ref, )]
bound[5] = [None, None, None, w3_app_icon_image_ref, "height", bind("height", width_h165, w3_app_icon_image_ref), width_h165, (w3_app_icon_image_ref, )]
_handlers[w3_app_icon_image.uid].append((bound, (0, 1, 2, 3, 4, 5)))
w5_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w5_ref, "size", w5.fast_bind("size", text_size_h168, w5_ref), text_size_h168, (w5_ref, )]
_handlers[w5.uid].append((bound, (0, )))
return partial(_d39, w3_app_icon_image_bound, w5_bound, w2_prev_icon_image_bound, root_bound, dispatch_objs, (w1, w2_prev_icon_image, w3_app_icon_image, w4, w5))
def _d39(w3_app_icon_image_bound, w5_bound, w2_prev_icon_image_bound, root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
if dispatch_objs[5] is not None:
obj, prop, count = dispatch_objs[5]
prop.dispatch_stale(obj, count)
return widgets
def pos_h170(root, w1, *args):
w1.pos = root.pos
def size_h171(root, w1, *args):
root = root.__self__
w1.size = root.separator_width, root.height
def opacity_h172(root, w1, *args):
w1.opacity = 1 if root.use_separator else 0
def background_image_h173(root, w1, *args):
root = root.__self__
w1.background_image = root.separator_image if root.use_separator else 'action_view'
# <ActionGroup> L637
_mc[40] = set()
def _r40(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.ActionSeparator(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[40]:
root_create_property = root.create_property
if not hasattr(root, "background_normal"):
root_create_property("background_normal", ('atlas://data/images/defaulttheme/action_group'))
if not hasattr(root, "background_down"):
root_create_property("background_down", ('atlas://data/images/defaulttheme/action_group_down'))
if not hasattr(root, "background_disabled_normal"):
root_create_property("background_disabled_normal", ('atlas://data/images/defaulttheme/action_group_disabled'))
if not hasattr(root, "border"):
root_create_property("border", (30, 30, 3, 3))
w1_create_property = w1.create_property
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "size"):
w1_create_property("size", (None))
if not hasattr(w1, "opacity"):
w1_create_property("opacity", (None))
if not hasattr(w1, "background_image"):
w1_create_property("background_image", (None))
_mc[40].add(root.__class__)
root.background_normal = 'atlas://data/images/defaulttheme/action_group'
root.background_down = 'atlas://data/images/defaulttheme/action_group_down'
root.background_disabled_normal = 'atlas://data/images/defaulttheme/action_group_disabled'
root.border = 30, 30, 3, 3
w1.pos = root.pos
w1.size = root.separator_width, root.height
w1.opacity = 1 if root.use_separator else 0
w1.background_image = root.separator_image if root.use_separator else 'action_view'
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b40(app, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b40, app, root, w1))
def _b40(app, root, w1):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 6
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h170, root_ref, w1_ref), pos_h170, [root_ref, w1_ref]]
if bound[0][5]:
prop = root.property("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "height", bind("height", size_h171, root_ref, w1_ref), size_h171, [root_ref, w1_ref]]
bound[2] = [None, None, None, root_ref, "separator_width", bind("separator_width", size_h171, root_ref, w1_ref), size_h171, [root_ref, w1_ref]]
bound[3] = [None, None, None, root_ref, "use_separator", bind("use_separator", opacity_h172, root_ref, w1_ref), opacity_h172, [root_ref, w1_ref]]
bound[4] = [None, None, None, root_ref, "use_separator", bind("use_separator", background_image_h173, root_ref, w1_ref), background_image_h173, [root_ref, w1_ref]]
bound[5] = [None, None, None, root_ref, "separator_image", bind("separator_image", background_image_h173, root_ref, w1_ref), background_image_h173, [root_ref, w1_ref]]
_handlers[w1.uid].append((bound, (0, 1, 2, 3, 4, 5)))
return partial(_d40, root_bound, dispatch_objs, (w1, ))
def _d40(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def width_h174(root, *args):
root = root.__self__
root.width = root.texture_size[0] if root.texture else root.minimum_width
def pos_h175(g2, root, *args):
root = root.__self__
g2.pos = root.center_x - sp(16), root.center_y - sp(16)
def source_h176(g2, root, *args):
g2.source = root.overflow_image
# <ActionOverflow> L648
_mc[41] = set()
def _r41(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_after_add = root.canvas.after.add
g1 = Factory.Color()
root_canvas_after_add(g1)
g2 = Factory.Rectangle()
root_canvas_after_add(g2)
if root.__class__ not in _mc[41]:
root_create_property = root.create_property
if not hasattr(root, "border"):
root_create_property("border", (3, 3, 3, 3))
if not hasattr(root, "background_normal"):
root_create_property("background_normal", ('atlas://data/images/defaulttheme/action_item'))
if not hasattr(root, "background_down"):
root_create_property("background_down", ('atlas://data/images/defaulttheme/action_item_down'))
if not hasattr(root, "background_disabled_normal"):
root_create_property("background_disabled_normal", ('atlas://data/images/defaulttheme/button_disabled'))
if not hasattr(root, "size_hint_x"):
root_create_property("size_hint_x", (None))
if not hasattr(root, "minimum_width"):
root_create_property("minimum_width", ('48sp'))
if not hasattr(root, "width"):
root_create_property("width", (None))
_mc[41].add(root.__class__)
root.border = 3, 3, 3, 3
root.background_normal = 'atlas://data/images/defaulttheme/action_item'
root.background_down = 'atlas://data/images/defaulttheme/action_item_down'
root.background_disabled_normal = 'atlas://data/images/defaulttheme/button_disabled'
root.size_hint_x = None
root.minimum_width = '48sp'
g1.rgb = 1, 1, 1
g2.size = sp(32), sp(32)
root.width = root.texture_size[0] if root.texture else root.minimum_width
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b41(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b41, app, g1, g2, root))
def _b41(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h175 = [pos_h175, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h175, None, None)
delayed_source_h176 = [source_h176, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h176, None, None)
root_bound = bound = [None, ] * 6
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "texture", bind("texture", width_h174, root_ref), width_h174, (root_ref, )]
bound[1] = [None, None, None, root_ref, "texture_size", bind("texture_size", width_h174, root_ref), width_h174, (root_ref, )]
bound[2] = [None, None, None, root_ref, "minimum_width", bind("minimum_width", width_h174, root_ref), width_h174, (root_ref, )]
bound[3] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h175), delayed_call_fn, (delayed_pos_h175, )]
bound[4] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h175), delayed_call_fn, (delayed_pos_h175, )]
bound[5] = [None, None, None, root_ref, "overflow_image", bind("overflow_image", delayed_call_fn, delayed_source_h176), delayed_call_fn, (delayed_source_h176, )]
_handlers[root.uid].append((bound, (0, 1, 2)))
_handlers[g2.uid].append((bound, (3, 4, 5)))
return tuple
# <ActionDropDown> L664
_mc[42] = set()
def _r42(root, builder_created):
if root.__class__ not in _mc[42]:
if not hasattr(root, "auto_width"):
root.create_property("auto_width", (None))
_mc[42].add(root.__class__)
root.auto_width = False
def orientation_h177(root, w1, *args):
w1.orientation = root.orientation
def pos_h178(root, w1, *args):
w1.pos = root.pos
def size_hint_x_h179(root, w2_container_title, *args):
w2_container_title.size_hint_x = None if root.orientation == 'horizontal' else 1
def size_hint_y_h180(root, w2_container_title, *args):
w2_container_title.size_hint_y = None if root.orientation == 'vertical' else 1
def width_h181(root, w2_container_title, *args):
root = root.__self__
w2_container_title.width = root.min_space if root.orientation == 'horizontal' else 100
def height_h182(root, w2_container_title, *args):
root = root.__self__
w2_container_title.height = root.min_space if root.orientation == 'vertical' else 100
def pos_h183(w3_sv, w4_container, *args):
w4_container.pos = w3_sv.pos
def size_h184(root, w4_container, *args):
w4_container.size = root.content_size
# <AccordionItem> L695
_mc[43] = set()
def _r43(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_BoxLayout = Factory.BoxLayout
w1 = cls_BoxLayout(parent=root, __builder_created=bfuncs)
w2_container_title = cls_BoxLayout(parent=w1, __builder_created=bfuncs)
w3_sv = Factory.StencilView(parent=w1, __builder_created=bfuncs)
w4_container = cls_BoxLayout(parent=w3_sv, __builder_created=bfuncs)
if root.__class__ not in _mc[43]:
root_create_property = root.create_property
if not hasattr(root, "container"):
root_create_property("container", (None))
if not hasattr(root, "container_title"):
root_create_property("container_title", (None))
w1_create_property = w1.create_property
if not hasattr(w1, "orientation"):
w1_create_property("orientation", (None))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
w2_container_title_create_property = w2_container_title.create_property
if not hasattr(w2_container_title, "size_hint_x"):
w2_container_title_create_property("size_hint_x", (None))
if not hasattr(w2_container_title, "size_hint_y"):
w2_container_title_create_property("size_hint_y", (None))
if not hasattr(w2_container_title, "width"):
w2_container_title_create_property("width", (None))
if not hasattr(w2_container_title, "height"):
w2_container_title_create_property("height", (None))
w4_container_create_property = w4_container.create_property
if not hasattr(w4_container, "pos"):
w4_container_create_property("pos", (None))
if not hasattr(w4_container, "size"):
w4_container_create_property("size", (None))
_mc[43].add(root.__class__)
root.container = w4_container
root.container_title = w2_container_title
w1.orientation = root.orientation
w1.pos = root.pos
w2_container_title.size_hint_x = None if root.orientation == 'horizontal' else 1
w2_container_title.size_hint_y = None if root.orientation == 'vertical' else 1
w2_container_title.width = root.min_space if root.orientation == 'horizontal' else 100
w2_container_title.height = root.min_space if root.orientation == 'vertical' else 100
w4_container.pos = w3_sv.pos
w4_container.size = root.content_size
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b43(app, root, w1, w2_container_title, w3_sv, w4_container))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b43, app, root, w1, w2_container_title, w3_sv, w4_container))
def _b43(app, root, w1, w2_container_title, w3_sv, w4_container):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w2_container_title_ref = w2_container_title.proxy_ref
w3_sv_ref = w3_sv.proxy_ref
w4_container_ref = w4_container.proxy_ref
dispatch_objs = [None, ] * 3
root_bound = bound = [None, ] * 9
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "orientation", bind("orientation", orientation_h177, root_ref, w1_ref), orientation_h177, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("orientation")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "pos", bind("pos", pos_h178, root_ref, w1_ref), pos_h178, [root_ref, w1_ref]]
if bound[1][5]:
prop = root_get_prop("pos")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "orientation", bind("orientation", size_hint_x_h179, root_ref, w2_container_title_ref), size_hint_x_h179, [root_ref, w2_container_title_ref]]
bound[3] = [None, None, None, root_ref, "orientation", bind("orientation", size_hint_y_h180, root_ref, w2_container_title_ref), size_hint_y_h180, [root_ref, w2_container_title_ref]]
bound[4] = [None, None, None, root_ref, "min_space", bind("min_space", width_h181, root_ref, w2_container_title_ref), width_h181, [root_ref, w2_container_title_ref]]
bound[5] = [None, None, None, root_ref, "orientation", bind("orientation", width_h181, root_ref, w2_container_title_ref), width_h181, [root_ref, w2_container_title_ref]]
bound[6] = [None, None, None, root_ref, "min_space", bind("min_space", height_h182, root_ref, w2_container_title_ref), height_h182, [root_ref, w2_container_title_ref]]
bound[7] = [None, None, None, root_ref, "orientation", bind("orientation", height_h182, root_ref, w2_container_title_ref), height_h182, [root_ref, w2_container_title_ref]]
bound[8] = [None, None, None, root_ref, "content_size", bind("content_size", size_h184, root_ref, w4_container_ref), size_h184, [root_ref, w4_container_ref]]
_handlers[w2_container_title.uid].append((bound, (2, 3, 4, 5, 6, 7)))
_handlers[w4_container.uid].append((bound, (8, )))
_handlers[w1.uid].append((bound, (0, 1)))
w3_sv_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w3_sv_ref, "pos", w3_sv.fast_bind("pos", pos_h183, w3_sv_ref, w4_container_ref), pos_h183, [w3_sv_ref, w4_container_ref]]
if bound[0][5]:
prop = w3_sv.property("pos")
dispatch_objs[2] = [w3_sv, prop, prop.dispatch_count(w3_sv)]
_handlers[w4_container.uid].append((bound, (0, )))
return partial(_d43, root_bound, w3_sv_bound, dispatch_objs, (w1, w2_container_title, w3_sv, w4_container))
def _d43(root_bound, w3_sv_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
return widgets
def pos_h185(g2, root, *args):
root = root.__self__
g2.pos = root.x, root.center_y
def size_h186(g2, root, *args):
g2.size = root.width, 1
# <SettingSpacer> L722
_mc[44] = set()
def _r44(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.Rectangle()
root_canvas_root_add(g2)
if root.__class__ not in _mc[44]:
root_create_property = root.create_property
if not hasattr(root, "size_hint_y"):
root_create_property("size_hint_y", (None))
if not hasattr(root, "height"):
root_create_property("height", (5))
_mc[44].add(root.__class__)
root.size_hint_y = None
root.height = 5
g1.rgb = .2, .2, .2
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b44(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b44, app, g1, g2, root))
def _b44(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h185 = [pos_h185, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h185, None, None)
delayed_size_h186 = [size_h186, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h186, None, None)
root_bound = bound = [None, ] * 3
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h185), delayed_call_fn, (delayed_pos_h185, )]
bound[1] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h185), delayed_call_fn, (delayed_pos_h185, )]
bound[2] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h186), delayed_call_fn, (delayed_size_h186, )]
_handlers[g2.uid].append((bound, (0, 1, 2)))
return tuple
def height_h187(root, w2_labellayout, *args):
root.height = w2_labellayout.texture_size[1] + dp(10)
def pos_h188(root, w1, *args):
w1.pos = root.pos
def text_h189(root, w2_labellayout, *args):
root = root.__self__
w2_labellayout.text = u'{0}\n[size=13sp][color=999999]{1}[/color][/size]'.format(root.title or '', root.desc or '')
def text_size_h190(w2_labellayout, *args):
w2_labellayout.text_size = w2_labellayout.width - 32, None
def rgba_h191(g4, root, *args):
g4.rgba = 47 / 255., 167 / 255., 212 / 255., root.selected_alpha
def pos_h192(g5, root, *args):
root = root.__self__
g5.pos = root.x, root.y + 1
def size_h193(g5, root, *args):
g5.size = root.size
def pos_h194(g7, root, *args):
root = root.__self__
g7.pos = root.x, root.y - 2
def size_h195(g7, root, *args):
g7.size = root.width, 1
# <SettingItem> L732
_mc[45] = set()
def _r45(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_BoxLayout = Factory.BoxLayout
cls_Color = Factory.Color
cls_Rectangle = Factory.Rectangle
root_canvas_root_add = root.canvas.add
w1 = cls_BoxLayout(parent=root, __builder_created=bfuncs)
w2_labellayout = Factory.Label(parent=w1, __builder_created=bfuncs)
w3_content = cls_BoxLayout(parent=w1, __builder_created=bfuncs)
g4 = cls_Color()
root_canvas_root_add(g4)
g5 = cls_Rectangle()
root_canvas_root_add(g5)
g6 = cls_Color()
root_canvas_root_add(g6)
g7 = cls_Rectangle()
root_canvas_root_add(g7)
if root.__class__ not in _mc[45]:
root_create_property = root.create_property
if not hasattr(root, "size_hint"):
root_create_property("size_hint", (None))
if not hasattr(root, "height"):
root_create_property("height", (None))
if not hasattr(root, "content"):
root_create_property("content", (None))
if not hasattr(w1, "pos"):
w1.create_property("pos", (None))
w2_labellayout_create_property = w2_labellayout.create_property
if not hasattr(w2_labellayout, "size_hint_x"):
w2_labellayout_create_property("size_hint_x", (.66))
if not hasattr(w2_labellayout, "markup"):
w2_labellayout_create_property("markup", (None))
if not hasattr(w2_labellayout, "text"):
w2_labellayout_create_property("text", (None))
if not hasattr(w2_labellayout, "font_size"):
w2_labellayout_create_property("font_size", ('15sp'))
if not hasattr(w2_labellayout, "text_size"):
w2_labellayout_create_property("text_size", (None))
if not hasattr(w3_content, "size_hint_x"):
w3_content.create_property("size_hint_x", (.33))
_mc[45].add(root.__class__)
root.size_hint = .25, None
root.content = w3_content
w2_labellayout.size_hint_x = .66
w2_labellayout.markup = True
w2_labellayout.font_size = '15sp'
w3_content.size_hint_x = .33
g6.rgb = .2, .2, .2
root.height = w2_labellayout.texture_size[1] + dp(10)
w1.pos = root.pos
w2_labellayout.text = u'{0}\n[size=13sp][color=999999]{1}[/color][/size]'.format(root.title or '', root.desc or '')
w2_labellayout.text_size = w2_labellayout.width - 32, None
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b45(app, g4, g5, g6, g7, root, w1, w2_labellayout, w3_content))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b45, app, g4, g5, g6, g7, root, w1, w2_labellayout, w3_content))
def _b45(app, g4, g5, g6, g7, root, w1, w2_labellayout, w3_content):
g5_ref = g5.proxy_ref
g7_ref = g7.proxy_ref
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w2_labellayout_ref = w2_labellayout.proxy_ref
delayed_rgba_h191 = [rgba_h191, g4.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h191, None, None)
delayed_pos_h192 = [pos_h192, g5_ref, root_ref, None]
delayed_call_fn(delayed_pos_h192, None, None)
delayed_size_h193 = [size_h193, g5_ref, root_ref, None]
delayed_call_fn(delayed_size_h193, None, None)
delayed_pos_h194 = [pos_h194, g7_ref, root_ref, None]
delayed_call_fn(delayed_pos_h194, None, None)
delayed_size_h195 = [size_h195, g7_ref, root_ref, None]
delayed_call_fn(delayed_size_h195, None, None)
dispatch_objs = [None, ] * 3
root_bound = bound = [None, ] * 10
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h188, root_ref, w1_ref), pos_h188, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "desc", bind("desc", text_h189, root_ref, w2_labellayout_ref), text_h189, [root_ref, w2_labellayout_ref]]
bound[2] = [None, None, None, root_ref, "title", bind("title", text_h189, root_ref, w2_labellayout_ref), text_h189, [root_ref, w2_labellayout_ref]]
bound[3] = [None, None, None, root_ref, "selected_alpha", bind("selected_alpha", delayed_call_fn, delayed_rgba_h191), delayed_call_fn, (delayed_rgba_h191, )]
bound[4] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h192), delayed_call_fn, (delayed_pos_h192, )]
if bound[4][5]:
prop = root_get_prop("x")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[5] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h192), delayed_call_fn, (delayed_pos_h192, )]
if bound[5][5]:
prop = root_get_prop("y")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[6] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h193), delayed_call_fn, (delayed_size_h193, )]
bound[7] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h194), delayed_call_fn, (delayed_pos_h194, )]
bound[8] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h194), delayed_call_fn, (delayed_pos_h194, )]
bound[9] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h195), delayed_call_fn, (delayed_size_h195, )]
_handlers[w2_labellayout.uid].append((bound, (1, 2)))
_handlers[g7.uid].append((bound, (7, 8, 9)))
_handlers[g5.uid].append((bound, (4, 5, 6)))
_handlers[g4.uid].append((bound, (3, )))
_handlers[w1.uid].append((bound, (0, )))
w2_labellayout_bound = bound = [None, ] * 2
bind = w2_labellayout.fast_bind
bound[0] = [None, None, None, w2_labellayout_ref, "texture_size", bind("texture_size", height_h187, root_ref, w2_labellayout_ref), height_h187, [root_ref, w2_labellayout_ref]]
bound[1] = [None, None, None, w2_labellayout_ref, "width", bind("width", text_size_h190, w2_labellayout_ref), text_size_h190, (w2_labellayout_ref, )]
_handlers[w2_labellayout.uid].append((bound, (1, )))
_handlers[root.uid].append((bound, (0, )))
return partial(_d45, w2_labellayout_bound, root_bound, dispatch_objs, (w1, w2_labellayout, w3_content))
def _d45(w2_labellayout_bound, root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
return widgets
def pos_h196(root, w1, *args):
w1.pos = root.pos
def active_h197(root, w1, *args):
root = root.__self__
w1.active = bool(root.values.index(root.value)) if root.value in root.values else False
def on_on_active_h13(root, *args):
root = root.__self__
root.value = root.values[int(args[1])]
# <SettingBoolean> L764
_mc[46] = set()
def _r46(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.Switch(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[46]:
w1_create_property = w1.create_property
if not hasattr(w1, "text"):
w1_create_property("text", ('Boolean'))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "active"):
w1_create_property("active", (None))
_mc[46].add(root.__class__)
w1.text = 'Boolean'
w1.pos = root.pos
w1.active = bool(root.values.index(root.value)) if root.value in root.values else False
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b46(app, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b46, app, root, w1))
def _b46(app, root, w1):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
dispatch_objs = [None, ] * 3
root_bound = bound = [None, ] * 5
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h196, root_ref, w1_ref), pos_h196, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "values", bind("values", active_h197, root_ref, w1_ref), active_h197, [root_ref, w1_ref]]
bound[2] = [None, None, None, root_ref, "value", bind("value", active_h197, root_ref, w1_ref), active_h197, [root_ref, w1_ref]]
if root.rebind_property("values"):
bound[3] = [4, 5, None, root_ref, "values", bind("values", rebind_callback, bound, 3), rebind_callback, (bound, 3)]
if bound[3][5]:
prop = root_get_prop("values")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
else:
bound[3] = [4, 5, None, None, "values", None, rebind_callback, (bound, 3)]
obj_root_values = root.values
if obj_root_values is not None and isinstance(obj_root_values, (EventDispatcher, Observable)):
bind = obj_root_values.fast_bind
bound[4] = [None, None, 3, obj_root_values.proxy_ref, "index", bind("index", active_h197, root_ref, w1_ref), active_h197, [root_ref, w1_ref]]
if bound[3] is not None and bound[4] is None:
bound[4] = [None, None, 3, None, "index", None, active_h197, [root_ref, w1_ref]]
_handlers[w1.uid].append((bound, (0, 1, 2, 4)))
w1.fast_bind("on_active", on_on_active_h13, root_ref)
prop = w1.property("on_active", quiet=True)
if prop is not None:
dispatch_objs[2] = [w1, prop, prop.dispatch_count(w1)]
return partial(_d46, root_bound, dispatch_objs, (w1, ))
def _d46(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
return widgets
def text_h198(root, w1, *args):
w1.text = root.value or ''
def pos_h199(root, w1, *args):
w1.pos = root.pos
# <SettingString> L771
_mc[47] = set()
def _r47(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.Label(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[47]:
w1_create_property = w1.create_property
if not hasattr(w1, "text"):
w1_create_property("text", (None))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "font_size"):
w1_create_property("font_size", ('15sp'))
_mc[47].add(root.__class__)
w1.font_size = '15sp'
w1.text = root.value or ''
w1.pos = root.pos
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b47(app, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b47, app, root, w1))
def _b47(app, root, w1):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 2
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "value", bind("value", text_h198, root_ref, w1_ref), text_h198, [root_ref, w1_ref]]
bound[1] = [None, None, None, root_ref, "pos", bind("pos", pos_h199, root_ref, w1_ref), pos_h199, [root_ref, w1_ref]]
if bound[1][5]:
prop = root.property("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
_handlers[w1.uid].append((bound, (0, 1)))
return partial(_d47, root_bound, dispatch_objs, (w1, ))
def _d47(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def text_h200(root, w1, *args):
w1.text = root.value or ''
def pos_h201(root, w1, *args):
w1.pos = root.pos
# <SettingPath> L777
_mc[48] = set()
def _r48(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.Label(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[48]:
w1_create_property = w1.create_property
if not hasattr(w1, "text"):
w1_create_property("text", (None))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "font_size"):
w1_create_property("font_size", ('15sp'))
_mc[48].add(root.__class__)
w1.font_size = '15sp'
w1.text = root.value or ''
w1.pos = root.pos
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b48(app, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b48, app, root, w1))
def _b48(app, root, w1):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 2
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "value", bind("value", text_h200, root_ref, w1_ref), text_h200, [root_ref, w1_ref]]
bound[1] = [None, None, None, root_ref, "pos", bind("pos", pos_h201, root_ref, w1_ref), pos_h201, [root_ref, w1_ref]]
if bound[1][5]:
prop = root.property("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
_handlers[w1.uid].append((bound, (0, 1)))
return partial(_d48, root_bound, dispatch_objs, (w1, ))
def _d48(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def text_h202(root, w1, *args):
w1.text = root.value or ''
def pos_h203(root, w1, *args):
w1.pos = root.pos
# <SettingOptions> L783
_mc[49] = set()
def _r49(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.Label(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[49]:
w1_create_property = w1.create_property
if not hasattr(w1, "text"):
w1_create_property("text", (None))
if not hasattr(w1, "pos"):
w1_create_property("pos", (None))
if not hasattr(w1, "font_size"):
w1_create_property("font_size", ('15sp'))
_mc[49].add(root.__class__)
w1.font_size = '15sp'
w1.text = root.value or ''
w1.pos = root.pos
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b49(app, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b49, app, root, w1))
def _b49(app, root, w1):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 2
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "value", bind("value", text_h202, root_ref, w1_ref), text_h202, [root_ref, w1_ref]]
bound[1] = [None, None, None, root_ref, "pos", bind("pos", pos_h203, root_ref, w1_ref), pos_h203, [root_ref, w1_ref]]
if bound[1][5]:
prop = root.property("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
_handlers[w1.uid].append((bound, (0, 1)))
return partial(_d49, root_bound, dispatch_objs, (w1, ))
def _d49(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def text_size_h204(root, *args):
root.text_size = root.width - 32, None
def height_h205(root, *args):
root.height = max(dp(20), root.texture_size[1] + dp(20))
def pos_h206(g2, root, *args):
root = root.__self__
g2.pos = root.x, root.y + 2
def size_h207(g2, root, *args):
root = root.__self__
g2.size = root.width, root.height - 2
def pos_h208(g4, root, *args):
root = root.__self__
g4.pos = root.x, root.y - 2
def size_h209(g4, root, *args):
g4.size = root.width, 1
# <SettingTitle> L789
_mc[50] = set()
def _r50(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Color = Factory.Color
cls_Rectangle = Factory.Rectangle
root_canvas_root_add = root.canvas.add
g1 = cls_Color()
root_canvas_root_add(g1)
g2 = cls_Rectangle()
root_canvas_root_add(g2)
g3 = cls_Color()
root_canvas_root_add(g3)
g4 = cls_Rectangle()
root_canvas_root_add(g4)
if root.__class__ not in _mc[50]:
root_create_property = root.create_property
if not hasattr(root, "text_size"):
root_create_property("text_size", (None))
if not hasattr(root, "size_hint_y"):
root_create_property("size_hint_y", (None))
if not hasattr(root, "height"):
root_create_property("height", (None))
if not hasattr(root, "color"):
root_create_property("color", ((.9, .9, .9, 1)))
if not hasattr(root, "font_size"):
root_create_property("font_size", ('15sp'))
_mc[50].add(root.__class__)
root.size_hint_y = None
root.color = (.9, .9, .9, 1)
root.font_size = '15sp'
g1.rgba = .15, .15, .15, .5
g3.rgb = .2, .2, .2
root.text_size = root.width - 32, None
root.height = max(dp(20), root.texture_size[1] + dp(20))
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b50(app, g1, g2, g3, g4, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b50, app, g1, g2, g3, g4, root))
def _b50(app, g1, g2, g3, g4, root):
g2_ref = g2.proxy_ref
g4_ref = g4.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h206 = [pos_h206, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h206, None, None)
delayed_size_h207 = [size_h207, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h207, None, None)
delayed_pos_h208 = [pos_h208, g4_ref, root_ref, None]
delayed_call_fn(delayed_pos_h208, None, None)
delayed_size_h209 = [size_h209, g4_ref, root_ref, None]
delayed_call_fn(delayed_size_h209, None, None)
root_bound = bound = [None, ] * 9
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "width", bind("width", text_size_h204, root_ref), text_size_h204, (root_ref, )]
bound[1] = [None, None, None, root_ref, "texture_size", bind("texture_size", height_h205, root_ref), height_h205, (root_ref, )]
bound[2] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h206), delayed_call_fn, (delayed_pos_h206, )]
bound[3] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h206), delayed_call_fn, (delayed_pos_h206, )]
bound[4] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h207), delayed_call_fn, (delayed_size_h207, )]
bound[5] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_size_h207), delayed_call_fn, (delayed_size_h207, )]
bound[6] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h208), delayed_call_fn, (delayed_pos_h208, )]
bound[7] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h208), delayed_call_fn, (delayed_pos_h208, )]
bound[8] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h209), delayed_call_fn, (delayed_size_h209, )]
_handlers[g4.uid].append((bound, (6, 7, 8)))
_handlers[root.uid].append((bound, (0, 1)))
_handlers[g2.uid].append((bound, (2, 3, 4, 5)))
return tuple
def text_size_h210(root, *args):
root.text_size = root.width - 32, None
def height_h211(root, *args):
root.height = root.texture_size[1] + dp(20)
def rgba_h212(g1, root, *args):
g1.rgba = 47 / 255., 167 / 255., 212 / 255., int(root.selected)
def pos_h213(g2, root, *args):
g2.pos = root.pos
def size_h214(g2, root, *args):
g2.size = root.size
# <SettingSidebarLabel> L807
_mc[51] = set()
def _r51(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_before_add = root.canvas.before.add
g1 = Factory.Color()
root_canvas_before_add(g1)
g2 = Factory.Rectangle()
root_canvas_before_add(g2)
if root.__class__ not in _mc[51]:
root_create_property = root.create_property
if not hasattr(root, "size_hint"):
root_create_property("size_hint", (None))
if not hasattr(root, "text_size"):
root_create_property("text_size", (None))
if not hasattr(root, "height"):
root_create_property("height", (None))
if not hasattr(root, "font_size"):
root_create_property("font_size", ('15sp'))
_mc[51].add(root.__class__)
root.size_hint = 1, None
root.font_size = '15sp'
root.text_size = root.width - 32, None
root.height = root.texture_size[1] + dp(20)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b51(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b51, app, g1, g2, root))
def _b51(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h212 = [rgba_h212, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h212, None, None)
delayed_pos_h213 = [pos_h213, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h213, None, None)
delayed_size_h214 = [size_h214, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h214, None, None)
root_bound = bound = [None, ] * 5
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "width", bind("width", text_size_h210, root_ref), text_size_h210, (root_ref, )]
bound[1] = [None, None, None, root_ref, "texture_size", bind("texture_size", height_h211, root_ref), height_h211, (root_ref, )]
bound[2] = [None, None, None, root_ref, "selected", bind("selected", delayed_call_fn, delayed_rgba_h212), delayed_call_fn, (delayed_rgba_h212, )]
bound[3] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h213), delayed_call_fn, (delayed_pos_h213, )]
bound[4] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h214), delayed_call_fn, (delayed_size_h214, )]
_handlers[root.uid].append((bound, (0, 1)))
_handlers[g2.uid].append((bound, (3, 4)))
_handlers[g1.uid].append((bound, (2, )))
return tuple
def height_h215(root, *args):
root.height = root.minimum_height
def text_h216(root, w1, *args):
w1.text = root.title
def text_size_h217(w1, *args):
w1.text_size = w1.width - 32, None
def height_h218(w1, *args):
w1.height = max(50, w1.texture_size[1] + 20)
def pos_h219(g3, w1, *args):
w1 = w1.__self__
g3.pos = w1.x, w1.y - 2
def size_h220(g3, w1, *args):
g3.size = w1.width, 1
# <SettingsPanel> L819
_mc[52] = set()
def _r52(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.Label(parent=root, __builder_created=bfuncs)
w1_canvas_after_add = w1.canvas.after.add
g2 = Factory.Color()
w1_canvas_after_add(g2)
g3 = Factory.Rectangle()
w1_canvas_after_add(g3)
if root.__class__ not in _mc[52]:
root_create_property = root.create_property
if not hasattr(root, "spacing"):
root_create_property("spacing", (5))
if not hasattr(root, "padding"):
root_create_property("padding", (5))
if not hasattr(root, "size_hint_y"):
root_create_property("size_hint_y", (None))
if not hasattr(root, "height"):
root_create_property("height", (None))
w1_create_property = w1.create_property
if not hasattr(w1, "size_hint_y"):
w1_create_property("size_hint_y", (None))
if not hasattr(w1, "text"):
w1_create_property("text", (None))
if not hasattr(w1, "text_size"):
w1_create_property("text_size", (None))
if not hasattr(w1, "height"):
w1_create_property("height", (None))
if not hasattr(w1, "color"):
w1_create_property("color", ((.5, .5, .5, 1)))
if not hasattr(w1, "font_size"):
w1_create_property("font_size", ('15sp'))
_mc[52].add(root.__class__)
root.spacing = 5
root.padding = 5
root.size_hint_y = None
w1.size_hint_y = None
w1.color = (.5, .5, .5, 1)
w1.font_size = '15sp'
g2.rgb = .2, .2, .2
root.height = root.minimum_height
w1.text = root.title
w1.text_size = w1.width - 32, None
w1.height = max(50, w1.texture_size[1] + 20)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b52(app, g2, g3, root, w1))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b52, app, g2, g3, root, w1))
def _b52(app, g2, g3, root, w1):
g3_ref = g3.proxy_ref
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
delayed_pos_h219 = [pos_h219, g3_ref, w1_ref, None]
delayed_call_fn(delayed_pos_h219, None, None)
delayed_size_h220 = [size_h220, g3_ref, w1_ref, None]
delayed_call_fn(delayed_size_h220, None, None)
root_bound = bound = [None, ] * 2
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "minimum_height", bind("minimum_height", height_h215, root_ref), height_h215, (root_ref, )]
bound[1] = [None, None, None, root_ref, "title", bind("title", text_h216, root_ref, w1_ref), text_h216, [root_ref, w1_ref]]
_handlers[root.uid].append((bound, (0, )))
_handlers[w1.uid].append((bound, (1, )))
w1_bound = bound = [None, ] * 5
bind = w1.fast_bind
bound[0] = [None, None, None, w1_ref, "width", bind("width", text_size_h217, w1_ref), text_size_h217, (w1_ref, )]
bound[1] = [None, None, None, w1_ref, "texture_size", bind("texture_size", height_h218, w1_ref), height_h218, (w1_ref, )]
bound[2] = [None, None, None, w1_ref, "x", bind("x", delayed_call_fn, delayed_pos_h219), delayed_call_fn, (delayed_pos_h219, )]
bound[3] = [None, None, None, w1_ref, "y", bind("y", delayed_call_fn, delayed_pos_h219), delayed_call_fn, (delayed_pos_h219, )]
bound[4] = [None, None, None, w1_ref, "width", bind("width", delayed_call_fn, delayed_size_h220), delayed_call_fn, (delayed_size_h220, )]
_handlers[g3.uid].append((bound, (2, 3, 4)))
_handlers[w1.uid].append((bound, (0, 1)))
return tuple
def pos_h221(g2, root, *args):
g2.pos = root.pos
def size_h222(g2, root, *args):
g2.size = root.size
# <Settings> L840
_mc[53] = set()
def _r53(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_before_add = root.canvas.before.add
g1 = Factory.Color()
root_canvas_before_add(g1)
g2 = Factory.Rectangle()
root_canvas_before_add(g2)
if root.__class__ not in _mc[53]:
if not hasattr(root, "orientation"):
root.create_property("orientation", ('horizontal'))
_mc[53].add(root.__class__)
root.orientation = 'horizontal'
g1.rgb = 0, 0, 0
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b53(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b53, app, g1, g2, root))
def _b53(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h221 = [pos_h221, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h221, None, None)
delayed_size_h222 = [size_h222, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h222, None, None)
root_bound = bound = [None, ] * 2
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h221), delayed_call_fn, (delayed_pos_h221, )]
bound[1] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h222), delayed_call_fn, (delayed_size_h222, )]
_handlers[g2.uid].append((bound, (0, 1)))
return tuple
def current_uid_h223(w1_menu, w2_content, *args):
w2_content.current_uid = w1_menu.selected_uid
# <InterfaceWithSidebar> L849
_mc[54] = set()
def _r54(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_menu = Factory.MenuSidebar(parent=root, __builder_created=bfuncs)
w2_content = Factory.ContentPanel(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[54]:
root_create_property = root.create_property
if not hasattr(root, "orientation"):
root_create_property("orientation", ('horizontal'))
if not hasattr(root, "menu"):
root_create_property("menu", (None))
if not hasattr(root, "content"):
root_create_property("content", (None))
if not hasattr(w2_content, "current_uid"):
w2_content.create_property("current_uid", (None))
_mc[54].add(root.__class__)
root.orientation = 'horizontal'
root.menu = w1_menu
root.content = w2_content
w2_content.current_uid = w1_menu.selected_uid
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b54(app, root, w1_menu, w2_content))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b54, app, root, w1_menu, w2_content))
def _b54(app, root, w1_menu, w2_content):
w1_menu_ref = w1_menu.proxy_ref
w2_content_ref = w2_content.proxy_ref
w1_menu_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w1_menu_ref, "selected_uid", w1_menu.fast_bind("selected_uid", current_uid_h223, w1_menu_ref, w2_content_ref), current_uid_h223, [w1_menu_ref, w2_content_ref]]
_handlers[w2_content.uid].append((bound, (0, )))
return tuple
def current_uid_h224(w1_menu, w2_content, *args):
w2_content.current_uid = w1_menu.selected_uid
# <InterfaceWithSpinner> L859
_mc[55] = set()
def _r55(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_menu = Factory.MenuSpinner(parent=root, __builder_created=bfuncs)
w2_content = Factory.ContentPanel(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[55]:
root_create_property = root.create_property
if not hasattr(root, "orientation"):
root_create_property("orientation", ('vertical'))
if not hasattr(root, "menu"):
root_create_property("menu", (None))
if not hasattr(root, "content"):
root_create_property("content", (None))
if not hasattr(w2_content, "current_uid"):
w2_content.create_property("current_uid", (None))
_mc[55].add(root.__class__)
root.orientation = 'vertical'
root.menu = w1_menu
root.content = w2_content
w2_content.current_uid = w1_menu.selected_uid
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b55(app, root, w1_menu, w2_content))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b55, app, root, w1_menu, w2_content))
def _b55(app, root, w1_menu, w2_content):
w1_menu_ref = w1_menu.proxy_ref
w2_content_ref = w2_content.proxy_ref
w1_menu_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w1_menu_ref, "selected_uid", w1_menu.fast_bind("selected_uid", current_uid_h224, w1_menu_ref, w2_content_ref), current_uid_h224, [w1_menu_ref, w2_content_ref]]
_handlers[w2_content.uid].append((bound, (0, )))
return tuple
def spinner_text_h225(root, w1_spinner, *args):
root.spinner_text = w1_spinner.text
def width_h226(root, w2_button, *args):
w2_button.width = min(dp(200), 0.4*root.width)
# <MenuSpinner> L869
_mc[56] = set()
def _r56(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_spinner = Factory.Spinner(parent=root, __builder_created=bfuncs)
w2_button = Factory.Button(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[56]:
root_create_property = root.create_property
if not hasattr(root, "orientation"):
root_create_property("orientation", ('horizontal'))
if not hasattr(root, "size_hint_y"):
root_create_property("size_hint_y", (None))
if not hasattr(root, "height"):
root_create_property("height", ('50dp'))
if not hasattr(root, "spinner"):
root_create_property("spinner", (None))
if not hasattr(root, "spinner_text"):
root_create_property("spinner_text", (None))
if not hasattr(root, "close_button"):
root_create_property("close_button", (None))
w2_button_create_property = w2_button.create_property
if not hasattr(w2_button, "text"):
w2_button_create_property("text", ('Close'))
if not hasattr(w2_button, "size_hint_x"):
w2_button_create_property("size_hint_x", (None))
if not hasattr(w2_button, "width"):
w2_button_create_property("width", (None))
if not hasattr(w2_button, "font_size"):
w2_button_create_property("font_size", ('15sp'))
_mc[56].add(root.__class__)
root.orientation = 'horizontal'
root.size_hint_y = None
root.height = '50dp'
root.spinner = w1_spinner
root.close_button = w2_button
w2_button.text = 'Close'
w2_button.size_hint_x = None
w2_button.font_size = '15sp'
root.spinner_text = w1_spinner.text
w2_button.width = min(dp(200), 0.4*root.width)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b56(app, root, w1_spinner, w2_button))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b56, app, root, w1_spinner, w2_button))
def _b56(app, root, w1_spinner, w2_button):
root_ref = root.proxy_ref
w1_spinner_ref = w1_spinner.proxy_ref
w2_button_ref = w2_button.proxy_ref
dispatch_objs = [None, ] * 1
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "width", root.fast_bind("width", width_h226, root_ref, w2_button_ref), width_h226, [root_ref, w2_button_ref]]
if bound[0][5]:
prop = root.property("width")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
_handlers[w2_button.uid].append((bound, (0, )))
w1_spinner_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w1_spinner_ref, "text", w1_spinner.fast_bind("text", spinner_text_h225, root_ref, w1_spinner_ref), spinner_text_h225, [root_ref, w1_spinner_ref]]
_handlers[root.uid].append((bound, (0, )))
return partial(_d56, w1_spinner_bound, root_bound, dispatch_objs, (w1_spinner, w2_button))
def _d56(w1_spinner_bound, root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
return widgets
def pos_h227(root, w1_menu, *args):
w1_menu.pos = root.pos
def pos_h228(g3, w1_menu, *args):
w1_menu = w1_menu.__self__
g3.pos = w1_menu.right - 1, w1_menu.y
def size_h229(g3, w1_menu, *args):
g3.size = 1, w1_menu.height
def width_h230(root, w4_button, *args):
w4_button.width = root.width - dp(20)
def height_h231(w4_button, *args):
w4_button.height = max(50, w4_button.texture_size[1] + dp(20))
def pos_h232(root, w4_button, *args):
root = root.__self__
w4_button.pos = root.x + dp(10), root.y + dp(10)
# <MenuSidebar> L886
_mc[57] = set()
def _r57(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_menu = Factory.GridLayout(parent=root, __builder_created=bfuncs)
w1_menu_canvas_after_add = w1_menu.canvas.after.add
g2 = Factory.Color()
w1_menu_canvas_after_add(g2)
g3 = Factory.Rectangle()
w1_menu_canvas_after_add(g3)
w4_button = Factory.Button(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[57]:
root_create_property = root.create_property
if not hasattr(root, "size_hint_x"):
root_create_property("size_hint_x", (None))
if not hasattr(root, "width"):
root_create_property("width", ('200dp'))
if not hasattr(root, "buttons_layout"):
root_create_property("buttons_layout", (None))
if not hasattr(root, "close_button"):
root_create_property("close_button", (None))
w1_menu_create_property = w1_menu.create_property
if not hasattr(w1_menu, "pos"):
w1_menu_create_property("pos", (None))
if not hasattr(w1_menu, "cols"):
w1_menu_create_property("cols", (1))
if not hasattr(w1_menu, "orientation"):
w1_menu_create_property("orientation", ('vertical'))
if not hasattr(w1_menu, "padding"):
w1_menu_create_property("padding", (5))
w4_button_create_property = w4_button.create_property
if not hasattr(w4_button, "text"):
w4_button_create_property("text", ('Close'))
if not hasattr(w4_button, "size_hint"):
w4_button_create_property("size_hint", (None))
if not hasattr(w4_button, "width"):
w4_button_create_property("width", (None))
if not hasattr(w4_button, "height"):
w4_button_create_property("height", (None))
if not hasattr(w4_button, "pos"):
w4_button_create_property("pos", (None))
if not hasattr(w4_button, "font_size"):
w4_button_create_property("font_size", ('15sp'))
_mc[57].add(root.__class__)
root.size_hint_x = None
root.width = '200dp'
root.buttons_layout = w1_menu
root.close_button = w4_button
w1_menu.cols = 1
w1_menu.orientation = 'vertical'
w1_menu.padding = 5
g2.rgb = .2, .2, .2
w4_button.text = 'Close'
w4_button.size_hint = None, None
w4_button.font_size = '15sp'
w1_menu.pos = root.pos
w4_button.width = root.width - dp(20)
w4_button.height = max(50, w4_button.texture_size[1] + dp(20))
w4_button.pos = root.x + dp(10), root.y + dp(10)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b57(app, g2, g3, root, w1_menu, w4_button))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b57, app, g2, g3, root, w1_menu, w4_button))
def _b57(app, g2, g3, root, w1_menu, w4_button):
g3_ref = g3.proxy_ref
root_ref = root.proxy_ref
w1_menu_ref = w1_menu.proxy_ref
w4_button_ref = w4_button.proxy_ref
delayed_pos_h228 = [pos_h228, g3_ref, w1_menu_ref, None]
delayed_call_fn(delayed_pos_h228, None, None)
delayed_size_h229 = [size_h229, g3_ref, w1_menu_ref, None]
delayed_call_fn(delayed_size_h229, None, None)
dispatch_objs = [None, ] * 4
root_bound = bound = [None, ] * 4
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "pos", bind("pos", pos_h227, root_ref, w1_menu_ref), pos_h227, [root_ref, w1_menu_ref]]
if bound[0][5]:
prop = root_get_prop("pos")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "width", bind("width", width_h230, root_ref, w4_button_ref), width_h230, [root_ref, w4_button_ref]]
if bound[1][5]:
prop = root_get_prop("width")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "x", bind("x", pos_h232, root_ref, w4_button_ref), pos_h232, [root_ref, w4_button_ref]]
if bound[2][5]:
prop = root_get_prop("x")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[3] = [None, None, None, root_ref, "y", bind("y", pos_h232, root_ref, w4_button_ref), pos_h232, [root_ref, w4_button_ref]]
if bound[3][5]:
prop = root_get_prop("y")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
_handlers[w4_button.uid].append((bound, (1, 2, 3)))
_handlers[w1_menu.uid].append((bound, (0, )))
w1_menu_bound = bound = [None, ] * 3
bind = w1_menu.fast_bind
bound[0] = [None, None, None, w1_menu_ref, "right", bind("right", delayed_call_fn, delayed_pos_h228), delayed_call_fn, (delayed_pos_h228, )]
bound[1] = [None, None, None, w1_menu_ref, "y", bind("y", delayed_call_fn, delayed_pos_h228), delayed_call_fn, (delayed_pos_h228, )]
bound[2] = [None, None, None, w1_menu_ref, "height", bind("height", delayed_call_fn, delayed_size_h229), delayed_call_fn, (delayed_size_h229, )]
_handlers[g3.uid].append((bound, (0, 1, 2)))
w4_button_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w4_button_ref, "texture_size", w4_button.fast_bind("texture_size", height_h231, w4_button_ref), height_h231, (w4_button_ref, )]
_handlers[w4_button.uid].append((bound, (0, )))
return partial(_d57, w4_button_bound, root_bound, w1_menu_bound, dispatch_objs, (w1_menu, w4_button))
def _d57(w4_button_bound, root_bound, w1_menu_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
return widgets
def height_h233(w1_content, *args):
w1_content.height = w1_content.minimum_height
# <ContentPanel> L914
_mc[58] = set()
def _r58(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_content = Factory.GridLayout(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[58]:
root_create_property = root.create_property
if not hasattr(root, "do_scroll_x"):
root_create_property("do_scroll_x", (None))
if not hasattr(root, "container"):
root_create_property("container", (None))
w1_content_create_property = w1_content.create_property
if not hasattr(w1_content, "cols"):
w1_content_create_property("cols", (1))
if not hasattr(w1_content, "size_hint_y"):
w1_content_create_property("size_hint_y", (None))
if not hasattr(w1_content, "height"):
w1_content_create_property("height", (None))
_mc[58].add(root.__class__)
root.do_scroll_x = False
root.container = w1_content
w1_content.cols = 1
w1_content.size_hint_y = None
w1_content.height = w1_content.minimum_height
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b58(app, root, w1_content))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b58, app, root, w1_content))
def _b58(app, root, w1_content):
w1_content_ref = w1_content.proxy_ref
w1_content_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w1_content_ref, "minimum_height", w1_content.fast_bind("minimum_height", height_h233, w1_content_ref), height_h233, (w1_content_ref, )]
_handlers[w1_content.uid].append((bound, (0, )))
return tuple
def size_h234(root, w1_tp, *args):
w1_tp.size = root.size
def pos_h235(root, w1_tp, *args):
w1_tp.pos = root.pos
def width_h236(root, w2_button, *args):
w2_button.width = min(dp(200), 0.3*root.width)
def x_h237(root, w2_button, *args):
root = root.__self__
w2_button.x = root.x + root.width - w2_button.width
def y_h238(root, w2_button, *args):
root = root.__self__
w2_button.y = root.y + root.height - w2_button.height
# <InterfaceWithTabbedPanel> L923
_mc[59] = set()
def _r59(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1_tp = Factory.TabbedPanel(parent=root, __builder_created=bfuncs)
w2_button = Factory.Button(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[59]:
root_create_property = root.create_property
if not hasattr(root, "tabbedpanel"):
root_create_property("tabbedpanel", (None))
if not hasattr(root, "close_button"):
root_create_property("close_button", (None))
w1_tp_create_property = w1_tp.create_property
if not hasattr(w1_tp, "size"):
w1_tp_create_property("size", (None))
if not hasattr(w1_tp, "pos"):
w1_tp_create_property("pos", (None))
if not hasattr(w1_tp, "background_color"):
w1_tp_create_property("background_color", ((0,0,0,1)))
w2_button_create_property = w2_button.create_property
if not hasattr(w2_button, "text"):
w2_button_create_property("text", ('Close'))
if not hasattr(w2_button, "size_hint"):
w2_button_create_property("size_hint", (None))
if not hasattr(w2_button, "height"):
w2_button_create_property("height", ('45dp'))
if not hasattr(w2_button, "width"):
w2_button_create_property("width", (None))
if not hasattr(w2_button, "x"):
w2_button_create_property("x", (None))
if not hasattr(w2_button, "y"):
w2_button_create_property("y", (None))
_mc[59].add(root.__class__)
root.tabbedpanel = w1_tp
root.close_button = w2_button
w1_tp.background_color = (0,0,0,1)
w2_button.text = 'Close'
w2_button.size_hint = None, None
w2_button.height = '45dp'
w1_tp.size = root.size
w1_tp.pos = root.pos
w2_button.width = min(dp(200), 0.3*root.width)
w2_button.x = root.x + root.width - w2_button.width
w2_button.y = root.y + root.height - w2_button.height
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b59(app, root, w1_tp, w2_button))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b59, app, root, w1_tp, w2_button))
def _b59(app, root, w1_tp, w2_button):
root_ref = root.proxy_ref
w1_tp_ref = w1_tp.proxy_ref
w2_button_ref = w2_button.proxy_ref
dispatch_objs = [None, ] * 6
root_bound = bound = [None, ] * 7
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "size", bind("size", size_h234, root_ref, w1_tp_ref), size_h234, [root_ref, w1_tp_ref]]
if bound[0][5]:
prop = root_get_prop("size")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "pos", bind("pos", pos_h235, root_ref, w1_tp_ref), pos_h235, [root_ref, w1_tp_ref]]
if bound[1][5]:
prop = root_get_prop("pos")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "width", bind("width", width_h236, root_ref, w2_button_ref), width_h236, [root_ref, w2_button_ref]]
if bound[2][5]:
prop = root_get_prop("width")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[3] = [None, None, None, root_ref, "width", bind("width", x_h237, root_ref, w2_button_ref), x_h237, [root_ref, w2_button_ref]]
bound[4] = [None, None, None, root_ref, "x", bind("x", x_h237, root_ref, w2_button_ref), x_h237, [root_ref, w2_button_ref]]
if bound[4][5]:
prop = root_get_prop("x")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
bound[5] = [None, None, None, root_ref, "height", bind("height", y_h238, root_ref, w2_button_ref), y_h238, [root_ref, w2_button_ref]]
if bound[5][5]:
prop = root_get_prop("height")
dispatch_objs[4] = [root, prop, prop.dispatch_count(root)]
bound[6] = [None, None, None, root_ref, "y", bind("y", y_h238, root_ref, w2_button_ref), y_h238, [root_ref, w2_button_ref]]
if bound[6][5]:
prop = root_get_prop("y")
dispatch_objs[5] = [root, prop, prop.dispatch_count(root)]
_handlers[w1_tp.uid].append((bound, (0, 1)))
_handlers[w2_button.uid].append((bound, (2, 3, 4, 5, 6)))
w2_button_bound = bound = [None, ] * 2
bind = w2_button.fast_bind
bound[0] = [None, None, None, w2_button_ref, "width", bind("width", x_h237, root_ref, w2_button_ref), x_h237, [root_ref, w2_button_ref]]
bound[1] = [None, None, None, w2_button_ref, "height", bind("height", y_h238, root_ref, w2_button_ref), y_h238, [root_ref, w2_button_ref]]
_handlers[w2_button.uid].append((bound, (0, 1)))
return partial(_d59, w2_button_bound, root_bound, dispatch_objs, (w1_tp, w2_button))
def _d59(w2_button_bound, root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
if dispatch_objs[5] is not None:
obj, prop, count = dispatch_objs[5]
prop.dispatch_stale(obj, count)
return widgets
def rgba_h239(g1, root, *args):
root = root.__self__
g1.rgba = root._bar_color if (root.do_scroll_y and root.viewport_size[1] > root.height) else [0, 0, 0, 0]
def pos_h240(g2, root, *args):
root = root.__self__
g2.pos = (root.right - root.bar_width - root.bar_margin) if root.bar_pos_y == 'right' else (root.x + root.bar_margin), root.y + root.height * root.vbar[0]
def size_h241(g2, root, *args):
root = root.__self__
g2.size = min(root.bar_width, root.width), root.height * root.vbar[1]
def rgba_h242(g3, root, *args):
root = root.__self__
g3.rgba = root._bar_color if (root.do_scroll_x and root.viewport_size[0] > root.width) else [0, 0, 0, 0]
def pos_h243(g4, root, *args):
root = root.__self__
g4.pos = root.x + root.width * root.hbar[0], (root.y + root.bar_margin) if root.bar_pos_x == 'bottom' else (root.top - root.bar_margin - root.bar_width)
def size_h244(g4, root, *args):
root = root.__self__
g4.size = root.width * root.hbar[1], min(root.bar_width, root.height)
# <ScrollView> L942
def _r60(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Color = Factory.Color
cls_Rectangle = Factory.Rectangle
root_canvas_after_add = root.canvas.after.add
g1 = cls_Color()
root_canvas_after_add(g1)
g2 = cls_Rectangle()
root_canvas_after_add(g2)
g3 = cls_Color()
root_canvas_after_add(g3)
g4 = cls_Rectangle()
root_canvas_after_add(g4)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b60(app, g1, g2, g3, g4, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b60, app, g1, g2, g3, g4, root))
def _b60(app, g1, g2, g3, g4, root):
g2_ref = g2.proxy_ref
g4_ref = g4.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h239 = [rgba_h239, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h239, None, None)
delayed_pos_h240 = [pos_h240, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h240, None, None)
delayed_size_h241 = [size_h241, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h241, None, None)
delayed_rgba_h242 = [rgba_h242, g3.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h242, None, None)
delayed_pos_h243 = [pos_h243, g4_ref, root_ref, None]
delayed_call_fn(delayed_pos_h243, None, None)
delayed_size_h244 = [size_h244, g4_ref, root_ref, None]
delayed_call_fn(delayed_size_h244, None, None)
root_bound = bound = [None, ] * 32
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "_bar_color", bind("_bar_color", delayed_call_fn, delayed_rgba_h239), delayed_call_fn, (delayed_rgba_h239, )]
bound[1] = [None, None, None, root_ref, "viewport_size", bind("viewport_size", delayed_call_fn, delayed_rgba_h239), delayed_call_fn, (delayed_rgba_h239, )]
bound[2] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_rgba_h239), delayed_call_fn, (delayed_rgba_h239, )]
bound[3] = [None, None, None, root_ref, "do_scroll_y", bind("do_scroll_y", delayed_call_fn, delayed_rgba_h239), delayed_call_fn, (delayed_rgba_h239, )]
bound[4] = [None, None, None, root_ref, "bar_pos_y", bind("bar_pos_y", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[5] = [None, None, None, root_ref, "bar_margin", bind("bar_margin", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[6] = [None, None, None, root_ref, "bar_width", bind("bar_width", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[7] = [None, None, None, root_ref, "right", bind("right", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[8] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[9] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[10] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[11] = [None, None, None, root_ref, "vbar", bind("vbar", delayed_call_fn, delayed_pos_h240), delayed_call_fn, (delayed_pos_h240, )]
bound[12] = [None, None, None, root_ref, "vbar", bind("vbar", delayed_call_fn, delayed_size_h241), delayed_call_fn, (delayed_size_h241, )]
bound[13] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h241), delayed_call_fn, (delayed_size_h241, )]
bound[14] = [None, None, None, root_ref, "bar_width", bind("bar_width", delayed_call_fn, delayed_size_h241), delayed_call_fn, (delayed_size_h241, )]
bound[15] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_size_h241), delayed_call_fn, (delayed_size_h241, )]
bound[16] = [None, None, None, root_ref, "do_scroll_x", bind("do_scroll_x", delayed_call_fn, delayed_rgba_h242), delayed_call_fn, (delayed_rgba_h242, )]
bound[17] = [None, None, None, root_ref, "_bar_color", bind("_bar_color", delayed_call_fn, delayed_rgba_h242), delayed_call_fn, (delayed_rgba_h242, )]
bound[18] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_rgba_h242), delayed_call_fn, (delayed_rgba_h242, )]
bound[19] = [None, None, None, root_ref, "viewport_size", bind("viewport_size", delayed_call_fn, delayed_rgba_h242), delayed_call_fn, (delayed_rgba_h242, )]
bound[20] = [None, None, None, root_ref, "bar_margin", bind("bar_margin", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[21] = [None, None, None, root_ref, "y", bind("y", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[22] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[23] = [None, None, None, root_ref, "top", bind("top", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[24] = [None, None, None, root_ref, "x", bind("x", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[25] = [None, None, None, root_ref, "bar_pos_x", bind("bar_pos_x", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[26] = [None, None, None, root_ref, "bar_width", bind("bar_width", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[27] = [None, None, None, root_ref, "hbar", bind("hbar", delayed_call_fn, delayed_pos_h243), delayed_call_fn, (delayed_pos_h243, )]
bound[28] = [None, None, None, root_ref, "width", bind("width", delayed_call_fn, delayed_size_h244), delayed_call_fn, (delayed_size_h244, )]
bound[29] = [None, None, None, root_ref, "bar_width", bind("bar_width", delayed_call_fn, delayed_size_h244), delayed_call_fn, (delayed_size_h244, )]
bound[30] = [None, None, None, root_ref, "hbar", bind("hbar", delayed_call_fn, delayed_size_h244), delayed_call_fn, (delayed_size_h244, )]
bound[31] = [None, None, None, root_ref, "height", bind("height", delayed_call_fn, delayed_size_h244), delayed_call_fn, (delayed_size_h244, )]
_handlers[g4.uid].append((bound, (20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31)))
_handlers[g3.uid].append((bound, (16, 17, 18, 19)))
_handlers[g2.uid].append((bound, (4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)))
_handlers[g1.uid].append((bound, (0, 1, 2, 3)))
return tuple
def source_h245(root, w1, *args):
w1.source = root.source
def source_h246(root, w2, *args):
root = root.__self__
w2.source = root.image_overlay_play if not root.click_done else root.image_loading
# <VideoPlayerPreview> L960
_mc[61] = set()
def _r61(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Image = Factory.Image
w1 = cls_Image(parent=root, __builder_created=bfuncs)
w2 = cls_Image(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[61]:
root_create_property = root.create_property
if not hasattr(root, "pos_hint"):
root_create_property("pos_hint", ({'x': 0, 'y': 0}))
if not hasattr(root, "image_overlay_play"):
root_create_property("image_overlay_play", ('atlas://data/images/defaulttheme/player-play-overlay'))
if not hasattr(root, "image_loading"):
root_create_property("image_loading", ('atlas://data/images/image-loading.gif'))
w1_create_property = w1.create_property
if not hasattr(w1, "source"):
w1_create_property("source", (None))
if not hasattr(w1, "color"):
w1_create_property("color", ((.5, .5, .5, 1)))
if not hasattr(w1, "pos_hint"):
w1_create_property("pos_hint", ({'x': 0, 'y': 0}))
w2_create_property = w2.create_property
if not hasattr(w2, "source"):
w2_create_property("source", (None))
if not hasattr(w2, "pos_hint"):
w2_create_property("pos_hint", ({'x': 0, 'y': 0}))
_mc[61].add(root.__class__)
root.pos_hint = {'x': 0, 'y': 0}
root.image_overlay_play = 'atlas://data/images/defaulttheme/player-play-overlay'
root.image_loading = 'atlas://data/images/image-loading.gif'
w1.color = (.5, .5, .5, 1)
w1.pos_hint = {'x': 0, 'y': 0}
w2.pos_hint = {'x': 0, 'y': 0}
w1.source = root.source
w2.source = root.image_overlay_play if not root.click_done else root.image_loading
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b61(app, root, w1, w2))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b61, app, root, w1, w2))
def _b61(app, root, w1, w2):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w2_ref = w2.proxy_ref
dispatch_objs = [None, ] * 4
root_bound = bound = [None, ] * 4
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "source", bind("source", source_h245, root_ref, w1_ref), source_h245, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("source")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "image_loading", bind("image_loading", source_h246, root_ref, w2_ref), source_h246, [root_ref, w2_ref]]
if bound[1][5]:
prop = root_get_prop("image_loading")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "click_done", bind("click_done", source_h246, root_ref, w2_ref), source_h246, [root_ref, w2_ref]]
if bound[2][5]:
prop = root_get_prop("click_done")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[3] = [None, None, None, root_ref, "image_overlay_play", bind("image_overlay_play", source_h246, root_ref, w2_ref), source_h246, [root_ref, w2_ref]]
if bound[3][5]:
prop = root_get_prop("image_overlay_play")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
_handlers[w2.uid].append((bound, (1, 2, 3)))
_handlers[w1.uid].append((bound, (0, )))
return partial(_d61, root_bound, dispatch_objs, (w1, w2))
def _d61(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
return widgets
def size_hint_h247(root, *args):
root = root.__self__
root.size_hint = root.annotation['size_hint'] if 'size_hint' in root.annotation else (None, None)
def size_h248(root, *args):
root = root.__self__
root.size = root.annotation['size'] if 'size' in root.annotation else (root.texture_size[0] + 20, root.texture_size[1] + 20)
def pos_hint_h249(root, *args):
root = root.__self__
root.pos_hint = root.annotation['pos_hint'] if 'pos_hint' in root.annotation else {'center_x': .5, 'y': .05}
def rgba_h250(g1, root, *args):
root = root.__self__
g1.rgba = root.annotation['bgcolor'] if 'bgcolor' in root.annotation else (0, 0, 0, 0.8)
def pos_h251(g2, root, *args):
g2.pos = root.pos
def size_h252(g2, root, *args):
g2.size = root.size
def source_h253(g2, root, *args):
root = root.__self__
g2.source = root.annotation['bgsource'] if 'bgsource' in root.annotation else None
def border_h254(g2, root, *args):
root = root.__self__
g2.border = root.annotation['border'] if 'border' in root.annotation else (0, 0, 0, 0)
# <VideoPlayerAnnotation> L973
_mc[62] = set()
def _r62(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_before_add = root.canvas.before.add
g1 = Factory.Color()
root_canvas_before_add(g1)
g2 = Factory.BorderImage()
root_canvas_before_add(g2)
if root.__class__ not in _mc[62]:
root_create_property = root.create_property
if not hasattr(root, "size_hint"):
root_create_property("size_hint", (None))
if not hasattr(root, "size"):
root_create_property("size", (None))
if not hasattr(root, "pos_hint"):
root_create_property("pos_hint", (None))
_mc[62].add(root.__class__)
root.size_hint = root.annotation['size_hint'] if 'size_hint' in root.annotation else (None, None)
root.size = root.annotation['size'] if 'size' in root.annotation else (root.texture_size[0] + 20, root.texture_size[1] + 20)
root.pos_hint = root.annotation['pos_hint'] if 'pos_hint' in root.annotation else {'center_x': .5, 'y': .05}
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b62(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b62, app, g1, g2, root))
def _b62(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_rgba_h250 = [rgba_h250, g1.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h250, None, None)
delayed_pos_h251 = [pos_h251, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h251, None, None)
delayed_size_h252 = [size_h252, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h252, None, None)
delayed_source_h253 = [source_h253, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h253, None, None)
delayed_border_h254 = [border_h254, g2_ref, root_ref, None]
delayed_call_fn(delayed_border_h254, None, None)
root_bound = bound = [None, ] * 9
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "annotation", bind("annotation", size_hint_h247, root_ref), size_hint_h247, (root_ref, )]
bound[1] = [None, None, None, root_ref, "texture_size", bind("texture_size", size_h248, root_ref), size_h248, (root_ref, )]
bound[2] = [None, None, None, root_ref, "annotation", bind("annotation", size_h248, root_ref), size_h248, (root_ref, )]
bound[3] = [None, None, None, root_ref, "annotation", bind("annotation", pos_hint_h249, root_ref), pos_hint_h249, (root_ref, )]
bound[4] = [None, None, None, root_ref, "annotation", bind("annotation", delayed_call_fn, delayed_rgba_h250), delayed_call_fn, (delayed_rgba_h250, )]
bound[5] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h251), delayed_call_fn, (delayed_pos_h251, )]
bound[6] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h252), delayed_call_fn, (delayed_size_h252, )]
bound[7] = [None, None, None, root_ref, "annotation", bind("annotation", delayed_call_fn, delayed_source_h253), delayed_call_fn, (delayed_source_h253, )]
bound[8] = [None, None, None, root_ref, "annotation", bind("annotation", delayed_call_fn, delayed_border_h254), delayed_call_fn, (delayed_border_h254, )]
_handlers[root.uid].append((bound, (0, 1, 2, 3)))
_handlers[g2.uid].append((bound, (5, 6, 7, 8)))
_handlers[g1.uid].append((bound, (4, )))
return tuple
def source_h255(root, w3, *args):
w3.source = root.image_stop
def source_h256(root, w4, *args):
root = root.__self__
w4.source = root.image_pause if root.state == 'play' else root.image_play
def source_h257(root, w5, *args):
root = root.__self__
w5.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))
def max_h258(root, w7, *args):
root = root.__self__
w7.max = max(root.duration, root.position, 1)
def value_h259(root, w7, *args):
w7.value = root.position
# <VideoPlayer> L986
_mc[63] = set()
def _r63(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Widget = Factory.Widget
w1_container = Factory.FloatLayout(parent=root, __builder_created=bfuncs)
w2 = Factory.GridLayout(parent=root, __builder_created=bfuncs)
w3 = Factory.VideoPlayerStop(parent=w2, __builder_created=bfuncs)
w4 = Factory.VideoPlayerPlayPause(parent=w2, __builder_created=bfuncs)
w5 = Factory.VideoPlayerVolume(parent=w2, __builder_created=bfuncs)
w6 = cls_Widget(parent=w2, __builder_created=bfuncs)
w7 = Factory.VideoPlayerProgressBar(parent=w2, __builder_created=bfuncs)
w8 = cls_Widget(parent=w2, __builder_created=bfuncs)
if root.__class__ not in _mc[63]:
root_create_property = root.create_property
if not hasattr(root, "container"):
root_create_property("container", (None))
if not hasattr(root, "cols"):
root_create_property("cols", (1))
if not hasattr(w1_container, "cols"):
w1_container.create_property("cols", (1))
w2_create_property = w2.create_property
if not hasattr(w2, "rows"):
w2_create_property("rows", (1))
if not hasattr(w2, "size_hint_y"):
w2_create_property("size_hint_y", (None))
if not hasattr(w2, "height"):
w2_create_property("height", (44))
w3_create_property = w3.create_property
if not hasattr(w3, "size_hint_x"):
w3_create_property("size_hint_x", (None))
if not hasattr(w3, "video"):
w3_create_property("video", (None))
if not hasattr(w3, "width"):
w3_create_property("width", (44))
if not hasattr(w3, "source"):
w3_create_property("source", (None))
w4_create_property = w4.create_property
if not hasattr(w4, "size_hint_x"):
w4_create_property("size_hint_x", (None))
if not hasattr(w4, "video"):
w4_create_property("video", (None))
if not hasattr(w4, "width"):
w4_create_property("width", (44))
if not hasattr(w4, "source"):
w4_create_property("source", (None))
w5_create_property = w5.create_property
if not hasattr(w5, "video"):
w5_create_property("video", (None))
if not hasattr(w5, "size_hint_x"):
w5_create_property("size_hint_x", (None))
if not hasattr(w5, "width"):
w5_create_property("width", (44))
if not hasattr(w5, "source"):
w5_create_property("source", (None))
w6_create_property = w6.create_property
if not hasattr(w6, "size_hint_x"):
w6_create_property("size_hint_x", (None))
if not hasattr(w6, "width"):
w6_create_property("width", (5))
w7_create_property = w7.create_property
if not hasattr(w7, "video"):
w7_create_property("video", (None))
if not hasattr(w7, "max"):
w7_create_property("max", (None))
if not hasattr(w7, "value"):
w7_create_property("value", (None))
w8_create_property = w8.create_property
if not hasattr(w8, "size_hint_x"):
w8_create_property("size_hint_x", (None))
if not hasattr(w8, "width"):
w8_create_property("width", (10))
_mc[63].add(root.__class__)
root.container = w1_container
root.cols = 1
w1_container.cols = 1
w2.rows = 1
w2.size_hint_y = None
w2.height = 44
w3.size_hint_x = None
w3.video = root
w3.width = 44
w4.size_hint_x = None
w4.video = root
w4.width = 44
w5.video = root
w5.size_hint_x = None
w5.width = 44
w6.size_hint_x = None
w6.width = 5
w7.video = root
w8.size_hint_x = None
w8.width = 10
w3.source = root.image_stop
w4.source = root.image_pause if root.state == 'play' else root.image_play
w5.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))
w7.max = max(root.duration, root.position, 1)
w7.value = root.position
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b63(app, root, w1_container, w2, w3, w4, w5, w6, w7, w8))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b63, app, root, w1_container, w2, w3, w4, w5, w6, w7, w8))
def _b63(app, root, w1_container, w2, w3, w4, w5, w6, w7, w8):
root_ref = root.proxy_ref
w3_ref = w3.proxy_ref
w4_ref = w4.proxy_ref
w5_ref = w5.proxy_ref
w7_ref = w7.proxy_ref
root_bound = bound = [None, ] * 12
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "image_stop", bind("image_stop", source_h255, root_ref, w3_ref), source_h255, [root_ref, w3_ref]]
bound[1] = [None, None, None, root_ref, "image_play", bind("image_play", source_h256, root_ref, w4_ref), source_h256, [root_ref, w4_ref]]
bound[2] = [None, None, None, root_ref, "image_pause", bind("image_pause", source_h256, root_ref, w4_ref), source_h256, [root_ref, w4_ref]]
bound[3] = [None, None, None, root_ref, "state", bind("state", source_h256, root_ref, w4_ref), source_h256, [root_ref, w4_ref]]
bound[4] = [None, None, None, root_ref, "image_volumelow", bind("image_volumelow", source_h257, root_ref, w5_ref), source_h257, [root_ref, w5_ref]]
bound[5] = [None, None, None, root_ref, "image_volumehigh", bind("image_volumehigh", source_h257, root_ref, w5_ref), source_h257, [root_ref, w5_ref]]
bound[6] = [None, None, None, root_ref, "image_volumemedium", bind("image_volumemedium", source_h257, root_ref, w5_ref), source_h257, [root_ref, w5_ref]]
bound[7] = [None, None, None, root_ref, "image_volumemuted", bind("image_volumemuted", source_h257, root_ref, w5_ref), source_h257, [root_ref, w5_ref]]
bound[8] = [None, None, None, root_ref, "volume", bind("volume", source_h257, root_ref, w5_ref), source_h257, [root_ref, w5_ref]]
bound[9] = [None, None, None, root_ref, "position", bind("position", max_h258, root_ref, w7_ref), max_h258, [root_ref, w7_ref]]
bound[10] = [None, None, None, root_ref, "duration", bind("duration", max_h258, root_ref, w7_ref), max_h258, [root_ref, w7_ref]]
bound[11] = [None, None, None, root_ref, "position", bind("position", value_h259, root_ref, w7_ref), value_h259, [root_ref, w7_ref]]
_handlers[w7.uid].append((bound, (9, 10, 11)))
_handlers[w5.uid].append((bound, (4, 5, 6, 7, 8)))
_handlers[w4.uid].append((bound, (1, 2, 3)))
_handlers[w3.uid].append((bound, (0, )))
return tuple
def _checkbox_state_image_h260(root, *args):
root = root.__self__
root._checkbox_state_image = root.background_checkbox_down \
if root.active else root.background_checkbox_normal
def _checkbox_disabled_image_h261(root, *args):
root = root.__self__
root._checkbox_disabled_image = root.background_checkbox_disabled_down \
if root.active else root.background_checkbox_disabled_normal
def _radio_state_image_h262(root, *args):
root = root.__self__
root._radio_state_image = root.background_radio_down \
if root.active else root.background_radio_normal
def _radio_disabled_image_h263(root, *args):
root = root.__self__
root._radio_disabled_image = root.background_radio_disabled_down \
if root.active else root.background_radio_disabled_normal
def _checkbox_image_h264(root, *args):
root = root.__self__
root._checkbox_image = root._checkbox_disabled_image \
if root.disabled else root._checkbox_state_image
def _radio_image_h265(root, *args):
root = root.__self__
root._radio_image = root._radio_disabled_image \
if root.disabled else root._radio_state_image
def source_h266(g2, root, *args):
root = root.__self__
g2.source = root._radio_image if root.group else root._checkbox_image
def pos_h267(g2, root, *args):
root = root.__self__
g2.pos = int(root.center_x - sp(16)), int(root.center_y - sp(16))
# <CheckBox> L1034
_mc[64] = set()
def _r64(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
root_canvas_root_add = root.canvas.add
g1 = Factory.Color()
root_canvas_root_add(g1)
g2 = Factory.Rectangle()
root_canvas_root_add(g2)
if root.__class__ not in _mc[64]:
root_create_property = root.create_property
if not hasattr(root, "_checkbox_state_image"):
root_create_property("_checkbox_state_image", (None))
if not hasattr(root, "_checkbox_disabled_image"):
root_create_property("_checkbox_disabled_image", (None))
if not hasattr(root, "_radio_state_image"):
root_create_property("_radio_state_image", (None))
if not hasattr(root, "_radio_disabled_image"):
root_create_property("_radio_disabled_image", (None))
if not hasattr(root, "_checkbox_image"):
root_create_property("_checkbox_image", (None))
if not hasattr(root, "_radio_image"):
root_create_property("_radio_image", (None))
_mc[64].add(root.__class__)
g1.rgb = 1, 1, 1
g2.size = sp(32), sp(32)
root._checkbox_state_image = root.background_checkbox_down \
if root.active else root.background_checkbox_normal
root._checkbox_disabled_image = root.background_checkbox_disabled_down \
if root.active else root.background_checkbox_disabled_normal
root._radio_state_image = root.background_radio_down \
if root.active else root.background_radio_normal
root._radio_disabled_image = root.background_radio_disabled_down \
if root.active else root.background_radio_disabled_normal
root._checkbox_image = root._checkbox_disabled_image \
if root.disabled else root._checkbox_state_image
root._radio_image = root._radio_disabled_image \
if root.disabled else root._radio_state_image
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b64(app, g1, g2, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b64, app, g1, g2, root))
def _b64(app, g1, g2, root):
g2_ref = g2.proxy_ref
root_ref = root.proxy_ref
delayed_source_h266 = [source_h266, g2_ref, root_ref, None]
delayed_call_fn(delayed_source_h266, None, None)
delayed_pos_h267 = [pos_h267, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h267, None, None)
dispatch_objs = [None, ] * 9
root_bound = bound = [None, ] * 23
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "active", bind("active", _checkbox_state_image_h260, root_ref), _checkbox_state_image_h260, (root_ref, )]
if bound[0][5]:
prop = root_get_prop("active")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "background_checkbox_down", bind("background_checkbox_down", _checkbox_state_image_h260, root_ref), _checkbox_state_image_h260, (root_ref, )]
if bound[1][5]:
prop = root_get_prop("background_checkbox_down")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "background_checkbox_normal", bind("background_checkbox_normal", _checkbox_state_image_h260, root_ref), _checkbox_state_image_h260, (root_ref, )]
if bound[2][5]:
prop = root_get_prop("background_checkbox_normal")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[3] = [None, None, None, root_ref, "active", bind("active", _checkbox_disabled_image_h261, root_ref), _checkbox_disabled_image_h261, (root_ref, )]
bound[4] = [None, None, None, root_ref, "background_checkbox_disabled_down", bind("background_checkbox_disabled_down", _checkbox_disabled_image_h261, root_ref), _checkbox_disabled_image_h261, (root_ref, )]
if bound[4][5]:
prop = root_get_prop("background_checkbox_disabled_down")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
bound[5] = [None, None, None, root_ref, "background_checkbox_disabled_normal", bind("background_checkbox_disabled_normal", _checkbox_disabled_image_h261, root_ref), _checkbox_disabled_image_h261, (root_ref, )]
if bound[5][5]:
prop = root_get_prop("background_checkbox_disabled_normal")
dispatch_objs[4] = [root, prop, prop.dispatch_count(root)]
bound[6] = [None, None, None, root_ref, "background_radio_down", bind("background_radio_down", _radio_state_image_h262, root_ref), _radio_state_image_h262, (root_ref, )]
if bound[6][5]:
prop = root_get_prop("background_radio_down")
dispatch_objs[5] = [root, prop, prop.dispatch_count(root)]
bound[7] = [None, None, None, root_ref, "background_radio_normal", bind("background_radio_normal", _radio_state_image_h262, root_ref), _radio_state_image_h262, (root_ref, )]
if bound[7][5]:
prop = root_get_prop("background_radio_normal")
dispatch_objs[6] = [root, prop, prop.dispatch_count(root)]
bound[8] = [None, None, None, root_ref, "active", bind("active", _radio_state_image_h262, root_ref), _radio_state_image_h262, (root_ref, )]
bound[9] = [None, None, None, root_ref, "active", bind("active", _radio_disabled_image_h263, root_ref), _radio_disabled_image_h263, (root_ref, )]
bound[10] = [None, None, None, root_ref, "background_radio_disabled_down", bind("background_radio_disabled_down", _radio_disabled_image_h263, root_ref), _radio_disabled_image_h263, (root_ref, )]
if bound[10][5]:
prop = root_get_prop("background_radio_disabled_down")
dispatch_objs[7] = [root, prop, prop.dispatch_count(root)]
bound[11] = [None, None, None, root_ref, "background_radio_disabled_normal", bind("background_radio_disabled_normal", _radio_disabled_image_h263, root_ref), _radio_disabled_image_h263, (root_ref, )]
if bound[11][5]:
prop = root_get_prop("background_radio_disabled_normal")
dispatch_objs[8] = [root, prop, prop.dispatch_count(root)]
bound[12] = [None, None, None, root_ref, "_checkbox_disabled_image", bind("_checkbox_disabled_image", _checkbox_image_h264, root_ref), _checkbox_image_h264, (root_ref, )]
bound[13] = [None, None, None, root_ref, "disabled", bind("disabled", _checkbox_image_h264, root_ref), _checkbox_image_h264, (root_ref, )]
bound[14] = [None, None, None, root_ref, "_checkbox_state_image", bind("_checkbox_state_image", _checkbox_image_h264, root_ref), _checkbox_image_h264, (root_ref, )]
bound[15] = [None, None, None, root_ref, "disabled", bind("disabled", _radio_image_h265, root_ref), _radio_image_h265, (root_ref, )]
bound[16] = [None, None, None, root_ref, "_radio_disabled_image", bind("_radio_disabled_image", _radio_image_h265, root_ref), _radio_image_h265, (root_ref, )]
bound[17] = [None, None, None, root_ref, "_radio_state_image", bind("_radio_state_image", _radio_image_h265, root_ref), _radio_image_h265, (root_ref, )]
bound[18] = [None, None, None, root_ref, "group", bind("group", delayed_call_fn, delayed_source_h266), delayed_call_fn, (delayed_source_h266, )]
bound[19] = [None, None, None, root_ref, "_checkbox_image", bind("_checkbox_image", delayed_call_fn, delayed_source_h266), delayed_call_fn, (delayed_source_h266, )]
bound[20] = [None, None, None, root_ref, "_radio_image", bind("_radio_image", delayed_call_fn, delayed_source_h266), delayed_call_fn, (delayed_source_h266, )]
bound[21] = [None, None, None, root_ref, "center_y", bind("center_y", delayed_call_fn, delayed_pos_h267), delayed_call_fn, (delayed_pos_h267, )]
bound[22] = [None, None, None, root_ref, "center_x", bind("center_x", delayed_call_fn, delayed_pos_h267), delayed_call_fn, (delayed_pos_h267, )]
_handlers[root.uid].append((bound, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)))
_handlers[g2.uid].append((bound, (18, 19, 20, 21, 22)))
return partial(_d64, root_bound, dispatch_objs, ())
def _d64(root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
if dispatch_objs[5] is not None:
obj, prop, count = dispatch_objs[5]
prop.dispatch_stale(obj, count)
if dispatch_objs[6] is not None:
obj, prop, count = dispatch_objs[6]
prop.dispatch_stale(obj, count)
if dispatch_objs[7] is not None:
obj, prop, count = dispatch_objs[7]
prop.dispatch_stale(obj, count)
if dispatch_objs[8] is not None:
obj, prop, count = dispatch_objs[8]
prop.dispatch_stale(obj, count)
return widgets
def pos_h268(g2, root, *args):
g2.pos = root.pos
def size_h269(g2, root, *args):
g2.size = root.size
def pos_h270(g5, root, *args):
g5.pos = root.pos
def size_h271(g5, root, *args):
g5.size = root.size
# <ScreenManager> L1065
def _r65(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_Rectangle = Factory.Rectangle
root_canvas_before_add = root.canvas.before.add
root_canvas_after_add = root.canvas.after.add
g1 = Factory.StencilPush()
root_canvas_before_add(g1)
g2 = cls_Rectangle()
root_canvas_before_add(g2)
g3 = Factory.StencilUse()
root_canvas_before_add(g3)
g4 = Factory.StencilUnUse()
root_canvas_after_add(g4)
g5 = cls_Rectangle()
root_canvas_after_add(g5)
g6 = Factory.StencilPop()
root_canvas_after_add(g6)
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b65(app, g1, g2, g3, g4, g5, g6, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b65, app, g1, g2, g3, g4, g5, g6, root))
def _b65(app, g1, g2, g3, g4, g5, g6, root):
g2_ref = g2.proxy_ref
g5_ref = g5.proxy_ref
root_ref = root.proxy_ref
delayed_pos_h268 = [pos_h268, g2_ref, root_ref, None]
delayed_call_fn(delayed_pos_h268, None, None)
delayed_size_h269 = [size_h269, g2_ref, root_ref, None]
delayed_call_fn(delayed_size_h269, None, None)
delayed_pos_h270 = [pos_h270, g5_ref, root_ref, None]
delayed_call_fn(delayed_pos_h270, None, None)
delayed_size_h271 = [size_h271, g5_ref, root_ref, None]
delayed_call_fn(delayed_size_h271, None, None)
root_bound = bound = [None, ] * 4
bind = root.fast_bind
bound[0] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h268), delayed_call_fn, (delayed_pos_h268, )]
bound[1] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h269), delayed_call_fn, (delayed_size_h269, )]
bound[2] = [None, None, None, root_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h270), delayed_call_fn, (delayed_pos_h270, )]
bound[3] = [None, None, None, root_ref, "size", bind("size", delayed_call_fn, delayed_size_h271), delayed_call_fn, (delayed_size_h271, )]
_handlers[g5.uid].append((bound, (2, 3)))
_handlers[g2.uid].append((bound, (0, 1)))
return tuple
# <ColorPicker_Input@TextInput> L1082
_mc[66] = set()
def _r66(root, builder_created):
if root.__class__ not in _mc[66]:
root_create_property = root.create_property
if not hasattr(root, "multiline"):
root_create_property("multiline", (None))
if not hasattr(root, "mroot"):
root_create_property("mroot", (None))
if not hasattr(root, "padding"):
root_create_property("padding", (None))
if not hasattr(root, "border"):
root_create_property("border", (4, 9, 4, 9))
_mc[66].add(root.__class__)
root.multiline = False
root.mroot = None
root.padding = sp(5)
root.border = 4, 9, 4, 9
def text_size_h272(root, *args):
root.text_size = root.size
# <ColorPicker_Label@Label> L1088
_mc[67] = set()
def _r67(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
if root.__class__ not in _mc[67]:
root_create_property = root.create_property
if not hasattr(root, "mroot"):
root_create_property("mroot", (None))
if not hasattr(root, "size_hint_x"):
root_create_property("size_hint_x", (None))
if not hasattr(root, "width"):
root_create_property("width", ('30sp'))
if not hasattr(root, "text_size"):
root_create_property("text_size", (None))
if not hasattr(root, "halign"):
root_create_property("halign", ("center"))
if not hasattr(root, "valign"):
root_create_property("valign", ("middle"))
_mc[67].add(root.__class__)
root.mroot = None
root.size_hint_x = None
root.width = '30sp'
root.halign = "center"
root.valign = "middle"
root.text_size = root.size
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b67(app, root))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b67, app, root))
def _b67(app, root):
root_ref = root.proxy_ref
root_bound = bound = [None, ] * 1
bound[0] = [None, None, None, root_ref, "size", root.fast_bind("size", text_size_h272, root_ref), text_size_h272, (root_ref, )]
_handlers[root.uid].append((bound, (0, )))
return tuple
def text_h273(root, w1, *args):
w1.text = root.text
def mroot_h274(root, w1, *args):
w1.mroot = root.mroot
def color_h275(root, w1, *args):
w1.color = root.foreground_color or (1, 1, 1, 1)
def mroot_h276(root, w3, *args):
w3.mroot = root.mroot
def text_h277(w3, w4_sldr, *args):
w3.text = str(int(w4_sldr.value))
def value_h278(root, w4_sldr, *args):
w4_sldr.value = root.color * 255
def on_on_text_h14(root, *args):
root = root.__self__
root.mroot._trigger_update_clr(root.mode, root.clr_idx, args[1])
def on_on_value_h15(root, *args):
root = root.__self__
root.mroot._trigger_update_clr(root.mode, root.clr_idx, args[1])
# <ColorPicker_Selector@BoxLayout> L1096
_mc[68] = set()
def _r68(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
w1 = Factory.ColorPicker_Label(parent=root, __builder_created=bfuncs)
w2 = Factory.AnchorLayout(parent=root, __builder_created=bfuncs)
w3 = Factory.ColorPicker_Input(parent=w2, __builder_created=bfuncs)
w4_sldr = Factory.Slider(parent=root, __builder_created=bfuncs)
if root.__class__ not in _mc[68]:
root_create_property = root.create_property
if not hasattr(root, "foreground_color"):
root_create_property("foreground_color", (None))
if not hasattr(root, "text"):
root_create_property("text", (''))
if not hasattr(root, "mroot"):
root_create_property("mroot", (None))
if not hasattr(root, "mode"):
root_create_property("mode", ('rgb'))
if not hasattr(root, "color"):
root_create_property("color", (0))
if not hasattr(root, "spacing"):
root_create_property("spacing", ('2sp'))
w1_create_property = w1.create_property
if not hasattr(w1, "text"):
w1_create_property("text", (None))
if not hasattr(w1, "mroot"):
w1_create_property("mroot", (None))
if not hasattr(w1, "color"):
w1_create_property("color", (None))
w2_create_property = w2.create_property
if not hasattr(w2, "size_hint_x"):
w2_create_property("size_hint_x", (None))
if not hasattr(w2, "width"):
w2_create_property("width", ('50sp'))
w3_create_property = w3.create_property
if not hasattr(w3, "mroot"):
w3_create_property("mroot", (None))
if not hasattr(w3, "text"):
w3_create_property("text", (None))
if not hasattr(w3, "size_hint_y"):
w3_create_property("size_hint_y", (None))
if not hasattr(w3, "height"):
w3_create_property("height", ('28sp'))
w4_sldr_create_property = w4_sldr.create_property
if not hasattr(w4_sldr, "size_hint"):
w4_sldr_create_property("size_hint", (1, .25))
if not hasattr(w4_sldr, "pos_hint"):
w4_sldr_create_property("pos_hint", ({'center_y':.5}))
if not hasattr(w4_sldr, "range"):
w4_sldr_create_property("range", (0, 255))
if not hasattr(w4_sldr, "value"):
w4_sldr_create_property("value", (None))
_mc[68].add(root.__class__)
root.foreground_color = None
root.text = ''
root.mroot = None
root.mode = 'rgb'
root.color = 0
root.spacing = '2sp'
w2.size_hint_x = None
w2.width = '50sp'
w3.size_hint_y = None
w3.height = '28sp'
w4_sldr.size_hint = 1, .25
w4_sldr.pos_hint = {'center_y':.5}
w4_sldr.range = 0, 255
w1.text = root.text
w1.mroot = root.mroot
w1.color = root.foreground_color or (1, 1, 1, 1)
w3.mroot = root.mroot
w3.text = str(int(w4_sldr.value))
w4_sldr.value = root.color * 255
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b68(app, root, w1, w2, w3, w4_sldr))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b68, app, root, w1, w2, w3, w4_sldr))
def _b68(app, root, w1, w2, w3, w4_sldr):
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w3_ref = w3.proxy_ref
w4_sldr_ref = w4_sldr.proxy_ref
dispatch_objs = [None, ] * 5
root_bound = bound = [None, ] * 5
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "text", bind("text", text_h273, root_ref, w1_ref), text_h273, [root_ref, w1_ref]]
if bound[0][5]:
prop = root_get_prop("text")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "mroot", bind("mroot", mroot_h274, root_ref, w1_ref), mroot_h274, [root_ref, w1_ref]]
if bound[1][5]:
prop = root_get_prop("mroot")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[2] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", color_h275, root_ref, w1_ref), color_h275, [root_ref, w1_ref]]
if bound[2][5]:
prop = root_get_prop("foreground_color")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[3] = [None, None, None, root_ref, "mroot", bind("mroot", mroot_h276, root_ref, w3_ref), mroot_h276, [root_ref, w3_ref]]
bound[4] = [None, None, None, root_ref, "color", bind("color", value_h278, root_ref, w4_sldr_ref), value_h278, [root_ref, w4_sldr_ref]]
_handlers[w4_sldr.uid].append((bound, (4, )))
_handlers[w3.uid].append((bound, (3, )))
_handlers[w1.uid].append((bound, (0, 1, 2)))
w4_sldr_bound = bound = [None, ] * 1
bind = w4_sldr.fast_bind
bind("on_value", on_on_value_h15, root_ref)
prop = w4_sldr.property("on_value", quiet=True)
if prop is not None:
dispatch_objs[3] = [w4_sldr, prop, prop.dispatch_count(w4_sldr)]
bound[0] = [None, None, None, w4_sldr_ref, "value", bind("value", text_h277, w3_ref, w4_sldr_ref), text_h277, [w3_ref, w4_sldr_ref]]
_handlers[w3.uid].append((bound, (0, )))
w3.fast_bind("on_text", on_on_text_h14, root_ref)
prop = w3.property("on_text", quiet=True)
if prop is not None:
dispatch_objs[4] = [w3, prop, prop.dispatch_count(w3)]
return partial(_d68, w4_sldr_bound, root_bound, dispatch_objs, (w1, w2, w3, w4_sldr))
def _d68(w4_sldr_bound, root_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
return widgets
def foreground_color_h279(root, w16_wheel, *args):
root.foreground_color = (1, 1, 1, 1) if root.hsv[2] * w16_wheel.a < .5 else (0, 0, 0, 1)
def orientation_h280(root, w1, *args):
root = root.__self__
w1.orientation = 'vertical' if root.width < root.height else 'horizontal'
def size_hint_y_h281(root, w2, *args):
root = root.__self__
w2.size_hint_y = None if root.width < root.height else 1
def height_h282(root, w2, *args):
root = root.__self__
w2.height = sp(33) * 4 if root.width < root.height else w2.height
def color_h283(w16_wheel, w3, *args):
w3.color = w16_wheel.r
def foreground_color_h284(root, w3, *args):
w3.foreground_color = root.foreground_color
def size_hint_y_h285(root, w3, *args):
root = root.__self__
w3.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h286(root, w3, *args):
root = root.__self__
w3.size_hint_x = .5 if root.width < root.height else 1
def height_h287(root, w3, *args):
root = root.__self__
w3.height = '33sp' if root.width < root.height else w3.height
def color_h288(w16_wheel, w4, *args):
w4.color = w16_wheel.g
def foreground_color_h289(root, w4, *args):
w4.foreground_color = root.foreground_color
def size_hint_y_h290(root, w4, *args):
root = root.__self__
w4.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h291(root, w4, *args):
root = root.__self__
w4.size_hint_x = .5 if root.width < root.height else 1
def height_h292(root, w4, *args):
root = root.__self__
w4.height = '33sp' if root.width < root.height else w4.height
def color_h293(w16_wheel, w5, *args):
w5.color = w16_wheel.b
def foreground_color_h294(root, w5, *args):
w5.foreground_color = root.foreground_color
def size_hint_y_h295(root, w5, *args):
root = root.__self__
w5.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h296(root, w5, *args):
root = root.__self__
w5.size_hint_x = .5 if root.width < root.height else 1
def height_h297(root, w5, *args):
root = root.__self__
w5.height = '33sp' if root.width < root.height else w5.height
def color_h298(root, w6, *args):
w6.color = root.color[3]
def foreground_color_h299(root, w6, *args):
w6.foreground_color = root.foreground_color
def size_hint_y_h300(root, w6, *args):
root = root.__self__
w6.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h301(root, w6, *args):
root = root.__self__
w6.size_hint_x = .5 if root.width < root.height else 1
def height_h302(root, w6, *args):
root = root.__self__
w6.height = '33sp' if root.width < root.height else w6.height
def color_h303(root, w7, *args):
w7.color = root.hsv[0]
def foreground_color_h304(root, w7, *args):
w7.foreground_color = root.foreground_color
def size_hint_y_h305(root, w7, *args):
root = root.__self__
w7.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h306(root, w7, *args):
root = root.__self__
w7.size_hint_x = .5 if root.width < root.height else 1
def height_h307(root, w7, *args):
root = root.__self__
w7.height = '33sp' if root.width < root.height else w7.height
def color_h308(root, w8, *args):
w8.color = root.hsv[1]
def foreground_color_h309(root, w8, *args):
w8.foreground_color = root.foreground_color
def size_hint_y_h310(root, w8, *args):
root = root.__self__
w8.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h311(root, w8, *args):
root = root.__self__
w8.size_hint_x = .5 if root.width < root.height else 1
def height_h312(root, w8, *args):
root = root.__self__
w8.height = '33sp' if root.width < root.height else w8.height
def color_h313(root, w9, *args):
w9.color = root.hsv[2]
def foreground_color_h314(root, w9, *args):
w9.foreground_color = root.foreground_color
def size_hint_y_h315(root, w9, *args):
root = root.__self__
w9.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h316(root, w9, *args):
root = root.__self__
w9.size_hint_x = .5 if root.width < root.height else 1
def height_h317(root, w9, *args):
root = root.__self__
w9.height = '33sp' if root.width < root.height else w9.height
def size_hint_y_h318(root, w10, *args):
root = root.__self__
w10.size_hint_y = None if root.width < root.height else 0.125
def size_hint_x_h319(root, w10, *args):
root = root.__self__
w10.size_hint_x = .5 if root.width < root.height else 1
def height_h320(root, w10, *args):
root = root.__self__
w10.height = '33sp' if root.width < root.height else w10.height
def color_h321(root, w11, *args):
w11.color = root.foreground_color
def text_h322(root, w13, *args):
w13.text = str(root.hex_color)
def rgba_h323(g14, root, *args):
g14.rgba = root.color
def size_h324(g15, w2, *args):
g15.size = w2.size
def pos_h325(g15, w2, *args):
g15.pos = w2.pos
def _origin_h326(w16_wheel, *args):
w16_wheel = w16_wheel.__self__
w16_wheel._origin = (w16_wheel.center_x, w16_wheel.center_y)
def _radius_h327(w16_wheel, *args):
w16_wheel._radius = 0.45 * min(w16_wheel.size)
def color_h328(root, w16_wheel, *args):
w16_wheel.color = root.color
def on_on_text_h16(root, *args):
root._trigger_update_hex(args[1])
def on_on_color_h17(root, *args):
root.color[:3] = args[1][:3]
# <ColorPicker> L1126
_mc[69] = set()
def _r69(root, builder_created):
bfuncs = [] if builder_created is None else builder_created
cls_BoxLayout = Factory.BoxLayout
cls_ColorPicker_Selector = Factory.ColorPicker_Selector
w1 = cls_BoxLayout(parent=root, __builder_created=bfuncs)
w2 = Factory.StackLayout(parent=w1, __builder_created=bfuncs)
w2_canvas_root_add = w2.canvas.add
w3 = cls_ColorPicker_Selector(parent=w2, __builder_created=bfuncs)
w4 = cls_ColorPicker_Selector(parent=w2, __builder_created=bfuncs)
w5 = cls_ColorPicker_Selector(parent=w2, __builder_created=bfuncs)
w6 = cls_ColorPicker_Selector(parent=w2, __builder_created=bfuncs)
w7 = cls_ColorPicker_Selector(parent=w2, __builder_created=bfuncs)
w8 = cls_ColorPicker_Selector(parent=w2, __builder_created=bfuncs)
w9 = cls_ColorPicker_Selector(parent=w2, __builder_created=bfuncs)
w10 = cls_BoxLayout(parent=w2, __builder_created=bfuncs)
w11 = Factory.ColorPicker_Label(parent=w10, __builder_created=bfuncs)
w12 = Factory.AnchorLayout(parent=w10, __builder_created=bfuncs)
w13 = Factory.ColorPicker_Input(parent=w12, __builder_created=bfuncs)
g14 = Factory.Color()
w2_canvas_root_add(g14)
g15 = Factory.Rectangle()
w2_canvas_root_add(g15)
w16_wheel = Factory.ColorWheel(parent=w1, __builder_created=bfuncs)
if root.__class__ not in _mc[69]:
root_create_property = root.create_property
if not hasattr(root, "foreground_color"):
root_create_property("foreground_color", (None))
if not hasattr(root, "wheel"):
root_create_property("wheel", (None))
w1_create_property = w1.create_property
if not hasattr(w1, "orientation"):
w1_create_property("orientation", (None))
if not hasattr(w1, "spacing"):
w1_create_property("spacing", ('5sp'))
w2_create_property = w2.create_property
if not hasattr(w2, "orientation"):
w2_create_property("orientation", ('tb-lr'))
if not hasattr(w2, "size_hint_y"):
w2_create_property("size_hint_y", (None))
if not hasattr(w2, "height"):
w2_create_property("height", (None))
w3_create_property = w3.create_property
if not hasattr(w3, "mroot"):
w3_create_property("mroot", (None))
if not hasattr(w3, "text"):
w3_create_property("text", ('R'))
if not hasattr(w3, "clr_idx"):
w3_create_property("clr_idx", (0))
if not hasattr(w3, "color"):
w3_create_property("color", (None))
if not hasattr(w3, "foreground_color"):
w3_create_property("foreground_color", (None))
if not hasattr(w3, "size_hint_y"):
w3_create_property("size_hint_y", (None))
if not hasattr(w3, "size_hint_x"):
w3_create_property("size_hint_x", (None))
if not hasattr(w3, "height"):
w3_create_property("height", (None))
w4_create_property = w4.create_property
if not hasattr(w4, "mroot"):
w4_create_property("mroot", (None))
if not hasattr(w4, "text"):
w4_create_property("text", ('G'))
if not hasattr(w4, "clr_idx"):
w4_create_property("clr_idx", (1))
if not hasattr(w4, "color"):
w4_create_property("color", (None))
if not hasattr(w4, "foreground_color"):
w4_create_property("foreground_color", (None))
if not hasattr(w4, "size_hint_y"):
w4_create_property("size_hint_y", (None))
if not hasattr(w4, "size_hint_x"):
w4_create_property("size_hint_x", (None))
if not hasattr(w4, "height"):
w4_create_property("height", (None))
w5_create_property = w5.create_property
if not hasattr(w5, "mroot"):
w5_create_property("mroot", (None))
if not hasattr(w5, "text"):
w5_create_property("text", ('B'))
if not hasattr(w5, "clr_idx"):
w5_create_property("clr_idx", (2))
if not hasattr(w5, "color"):
w5_create_property("color", (None))
if not hasattr(w5, "foreground_color"):
w5_create_property("foreground_color", (None))
if not hasattr(w5, "size_hint_y"):
w5_create_property("size_hint_y", (None))
if not hasattr(w5, "size_hint_x"):
w5_create_property("size_hint_x", (None))
if not hasattr(w5, "height"):
w5_create_property("height", (None))
w6_create_property = w6.create_property
if not hasattr(w6, "mroot"):
w6_create_property("mroot", (None))
if not hasattr(w6, "text"):
w6_create_property("text", ('A'))
if not hasattr(w6, "clr_idx"):
w6_create_property("clr_idx", (3))
if not hasattr(w6, "color"):
w6_create_property("color", (None))
if not hasattr(w6, "foreground_color"):
w6_create_property("foreground_color", (None))
if not hasattr(w6, "size_hint_y"):
w6_create_property("size_hint_y", (None))
if not hasattr(w6, "size_hint_x"):
w6_create_property("size_hint_x", (None))
if not hasattr(w6, "height"):
w6_create_property("height", (None))
w7_create_property = w7.create_property
if not hasattr(w7, "mroot"):
w7_create_property("mroot", (None))
if not hasattr(w7, "mode"):
w7_create_property("mode", ('hsv'))
if not hasattr(w7, "text"):
w7_create_property("text", ('H'))
if not hasattr(w7, "clr_idx"):
w7_create_property("clr_idx", (0))
if not hasattr(w7, "color"):
w7_create_property("color", (None))
if not hasattr(w7, "foreground_color"):
w7_create_property("foreground_color", (None))
if not hasattr(w7, "size_hint_y"):
w7_create_property("size_hint_y", (None))
if not hasattr(w7, "size_hint_x"):
w7_create_property("size_hint_x", (None))
if not hasattr(w7, "height"):
w7_create_property("height", (None))
w8_create_property = w8.create_property
if not hasattr(w8, "mroot"):
w8_create_property("mroot", (None))
if not hasattr(w8, "mode"):
w8_create_property("mode", ('hsv'))
if not hasattr(w8, "text"):
w8_create_property("text", ('S'))
if not hasattr(w8, "clr_idx"):
w8_create_property("clr_idx", (1))
if not hasattr(w8, "color"):
w8_create_property("color", (None))
if not hasattr(w8, "foreground_color"):
w8_create_property("foreground_color", (None))
if not hasattr(w8, "size_hint_y"):
w8_create_property("size_hint_y", (None))
if not hasattr(w8, "size_hint_x"):
w8_create_property("size_hint_x", (None))
if not hasattr(w8, "height"):
w8_create_property("height", (None))
w9_create_property = w9.create_property
if not hasattr(w9, "mroot"):
w9_create_property("mroot", (None))
if not hasattr(w9, "mode"):
w9_create_property("mode", ('hsv'))
if not hasattr(w9, "text"):
w9_create_property("text", ('V'))
if not hasattr(w9, "clr_idx"):
w9_create_property("clr_idx", (2))
if not hasattr(w9, "color"):
w9_create_property("color", (None))
if not hasattr(w9, "foreground_color"):
w9_create_property("foreground_color", (None))
if not hasattr(w9, "size_hint_y"):
w9_create_property("size_hint_y", (None))
if not hasattr(w9, "size_hint_x"):
w9_create_property("size_hint_x", (None))
if not hasattr(w9, "height"):
w9_create_property("height", (None))
w10_create_property = w10.create_property
if not hasattr(w10, "size_hint_y"):
w10_create_property("size_hint_y", (None))
if not hasattr(w10, "size_hint_x"):
w10_create_property("size_hint_x", (None))
if not hasattr(w10, "height"):
w10_create_property("height", (None))
if not hasattr(w10, "spacing"):
w10_create_property("spacing", ('2sp'))
w11_create_property = w11.create_property
if not hasattr(w11, "mroot"):
w11_create_property("mroot", (None))
if not hasattr(w11, "text"):
w11_create_property("text", ('X'))
if not hasattr(w11, "color"):
w11_create_property("color", (None))
w13_create_property = w13.create_property
if not hasattr(w13, "size_hint_y"):
w13_create_property("size_hint_y", (None))
if not hasattr(w13, "height"):
w13_create_property("height", ('28sp'))
if not hasattr(w13, "mroot"):
w13_create_property("mroot", (None))
if not hasattr(w13, "text"):
w13_create_property("text", (None))
w16_wheel_create_property = w16_wheel.create_property
if not hasattr(w16_wheel, "_origin"):
w16_wheel_create_property("_origin", (None))
if not hasattr(w16_wheel, "_radius"):
w16_wheel_create_property("_radius", (None))
if not hasattr(w16_wheel, "color"):
w16_wheel_create_property("color", (None))
_mc[69].add(root.__class__)
root.wheel = w16_wheel
w1.spacing = '5sp'
w2.orientation = 'tb-lr'
w3.mroot = root
w3.text = 'R'
w3.clr_idx = 0
w4.mroot = root
w4.text = 'G'
w4.clr_idx = 1
w5.mroot = root
w5.text = 'B'
w5.clr_idx = 2
w6.mroot = root
w6.text = 'A'
w6.clr_idx = 3
w7.mroot = root
w7.mode = 'hsv'
w7.text = 'H'
w7.clr_idx = 0
w8.mroot = root
w8.mode = 'hsv'
w8.text = 'S'
w8.clr_idx = 1
w9.mroot = root
w9.mode = 'hsv'
w9.text = 'V'
w9.clr_idx = 2
w10.spacing = '2sp'
w11.mroot = root
w11.text = 'X'
w13.size_hint_y = None
w13.height = '28sp'
w13.mroot = root
root.foreground_color = (1, 1, 1, 1) if root.hsv[2] * w16_wheel.a < .5 else (0, 0, 0, 1)
w1.orientation = 'vertical' if root.width < root.height else 'horizontal'
w2.size_hint_y = None if root.width < root.height else 1
w2.height = sp(33) * 4 if root.width < root.height else w2.height
w3.color = w16_wheel.r
w3.foreground_color = root.foreground_color
w3.size_hint_y = None if root.width < root.height else 0.125
w3.size_hint_x = .5 if root.width < root.height else 1
w3.height = '33sp' if root.width < root.height else w3.height
w4.color = w16_wheel.g
w4.foreground_color = root.foreground_color
w4.size_hint_y = None if root.width < root.height else 0.125
w4.size_hint_x = .5 if root.width < root.height else 1
w4.height = '33sp' if root.width < root.height else w4.height
w5.color = w16_wheel.b
w5.foreground_color = root.foreground_color
w5.size_hint_y = None if root.width < root.height else 0.125
w5.size_hint_x = .5 if root.width < root.height else 1
w5.height = '33sp' if root.width < root.height else w5.height
w6.color = root.color[3]
w6.foreground_color = root.foreground_color
w6.size_hint_y = None if root.width < root.height else 0.125
w6.size_hint_x = .5 if root.width < root.height else 1
w6.height = '33sp' if root.width < root.height else w6.height
w7.color = root.hsv[0]
w7.foreground_color = root.foreground_color
w7.size_hint_y = None if root.width < root.height else 0.125
w7.size_hint_x = .5 if root.width < root.height else 1
w7.height = '33sp' if root.width < root.height else w7.height
w8.color = root.hsv[1]
w8.foreground_color = root.foreground_color
w8.size_hint_y = None if root.width < root.height else 0.125
w8.size_hint_x = .5 if root.width < root.height else 1
w8.height = '33sp' if root.width < root.height else w8.height
w9.color = root.hsv[2]
w9.foreground_color = root.foreground_color
w9.size_hint_y = None if root.width < root.height else 0.125
w9.size_hint_x = .5 if root.width < root.height else 1
w9.height = '33sp' if root.width < root.height else w9.height
w10.size_hint_y = None if root.width < root.height else 0.125
w10.size_hint_x = .5 if root.width < root.height else 1
w10.height = '33sp' if root.width < root.height else w10.height
w11.color = root.foreground_color
w13.text = str(root.hex_color)
w16_wheel._origin = (w16_wheel.center_x, w16_wheel.center_y)
w16_wheel._radius = 0.45 * min(w16_wheel.size)
w16_wheel.color = root.color
if builder_created is None:
bfuncs = [f() for f in bfuncs]
bfuncs.append(_b69(app, g14, g15, root, w1, w10, w11, w12, w13, w16_wheel, w2, w3, w4, w5, w6, w7, w8, w9))
bfuncs = [f() for f in reversed(bfuncs)]
for children in reversed(bfuncs):
for child in children:
child.dispatch("on_kv_apply", root)
else:
bfuncs.append(partial(_b69, app, g14, g15, root, w1, w10, w11, w12, w13, w16_wheel, w2, w3, w4, w5, w6, w7, w8, w9))
def _b69(app, g14, g15, root, w1, w10, w11, w12, w13, w16_wheel, w2, w3, w4, w5, w6, w7, w8, w9):
g15_ref = g15.proxy_ref
root_ref = root.proxy_ref
w1_ref = w1.proxy_ref
w10_ref = w10.proxy_ref
w11_ref = w11.proxy_ref
w13_ref = w13.proxy_ref
w16_wheel_ref = w16_wheel.proxy_ref
w2_ref = w2.proxy_ref
w3_ref = w3.proxy_ref
w4_ref = w4.proxy_ref
w5_ref = w5.proxy_ref
w6_ref = w6.proxy_ref
w7_ref = w7.proxy_ref
w8_ref = w8.proxy_ref
w9_ref = w9.proxy_ref
delayed_rgba_h323 = [rgba_h323, g14.proxy_ref, root_ref, None]
delayed_call_fn(delayed_rgba_h323, None, None)
delayed_size_h324 = [size_h324, g15_ref, w2_ref, None]
delayed_call_fn(delayed_size_h324, None, None)
delayed_pos_h325 = [pos_h325, g15_ref, w2_ref, None]
delayed_call_fn(delayed_pos_h325, None, None)
dispatch_objs = [None, ] * 16
root_bound = bound = [None, ] * 70
bind = root.fast_bind
root_get_prop = root.property
bound[0] = [None, None, None, root_ref, "hsv", bind("hsv", foreground_color_h279, root_ref, w16_wheel_ref), foreground_color_h279, [root_ref, w16_wheel_ref]]
if bound[0][5]:
prop = root_get_prop("hsv")
dispatch_objs[0] = [root, prop, prop.dispatch_count(root)]
bound[1] = [None, None, None, root_ref, "width", bind("width", orientation_h280, root_ref, w1_ref), orientation_h280, [root_ref, w1_ref]]
bound[2] = [None, None, None, root_ref, "height", bind("height", orientation_h280, root_ref, w1_ref), orientation_h280, [root_ref, w1_ref]]
bound[3] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h281, root_ref, w2_ref), size_hint_y_h281, [root_ref, w2_ref]]
bound[4] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h281, root_ref, w2_ref), size_hint_y_h281, [root_ref, w2_ref]]
bound[5] = [None, None, None, root_ref, "width", bind("width", height_h282, root_ref, w2_ref), height_h282, [root_ref, w2_ref]]
if bound[5][5]:
prop = root_get_prop("width")
dispatch_objs[1] = [root, prop, prop.dispatch_count(root)]
bound[6] = [None, None, None, root_ref, "height", bind("height", height_h282, root_ref, w2_ref), height_h282, [root_ref, w2_ref]]
if bound[6][5]:
prop = root_get_prop("height")
dispatch_objs[2] = [root, prop, prop.dispatch_count(root)]
bound[7] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", foreground_color_h284, root_ref, w3_ref), foreground_color_h284, [root_ref, w3_ref]]
if bound[7][5]:
prop = root_get_prop("foreground_color")
dispatch_objs[3] = [root, prop, prop.dispatch_count(root)]
bound[8] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h285, root_ref, w3_ref), size_hint_y_h285, [root_ref, w3_ref]]
bound[9] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h285, root_ref, w3_ref), size_hint_y_h285, [root_ref, w3_ref]]
bound[10] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h286, root_ref, w3_ref), size_hint_x_h286, [root_ref, w3_ref]]
bound[11] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h286, root_ref, w3_ref), size_hint_x_h286, [root_ref, w3_ref]]
bound[12] = [None, None, None, root_ref, "width", bind("width", height_h287, root_ref, w3_ref), height_h287, [root_ref, w3_ref]]
bound[13] = [None, None, None, root_ref, "height", bind("height", height_h287, root_ref, w3_ref), height_h287, [root_ref, w3_ref]]
bound[14] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", foreground_color_h289, root_ref, w4_ref), foreground_color_h289, [root_ref, w4_ref]]
bound[15] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h290, root_ref, w4_ref), size_hint_y_h290, [root_ref, w4_ref]]
bound[16] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h290, root_ref, w4_ref), size_hint_y_h290, [root_ref, w4_ref]]
bound[17] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h291, root_ref, w4_ref), size_hint_x_h291, [root_ref, w4_ref]]
bound[18] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h291, root_ref, w4_ref), size_hint_x_h291, [root_ref, w4_ref]]
bound[19] = [None, None, None, root_ref, "width", bind("width", height_h292, root_ref, w4_ref), height_h292, [root_ref, w4_ref]]
bound[20] = [None, None, None, root_ref, "height", bind("height", height_h292, root_ref, w4_ref), height_h292, [root_ref, w4_ref]]
bound[21] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", foreground_color_h294, root_ref, w5_ref), foreground_color_h294, [root_ref, w5_ref]]
bound[22] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h295, root_ref, w5_ref), size_hint_y_h295, [root_ref, w5_ref]]
bound[23] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h295, root_ref, w5_ref), size_hint_y_h295, [root_ref, w5_ref]]
bound[24] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h296, root_ref, w5_ref), size_hint_x_h296, [root_ref, w5_ref]]
bound[25] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h296, root_ref, w5_ref), size_hint_x_h296, [root_ref, w5_ref]]
bound[26] = [None, None, None, root_ref, "width", bind("width", height_h297, root_ref, w5_ref), height_h297, [root_ref, w5_ref]]
bound[27] = [None, None, None, root_ref, "height", bind("height", height_h297, root_ref, w5_ref), height_h297, [root_ref, w5_ref]]
bound[28] = [None, None, None, root_ref, "color", bind("color", color_h298, root_ref, w6_ref), color_h298, [root_ref, w6_ref]]
if bound[28][5]:
prop = root_get_prop("color")
dispatch_objs[4] = [root, prop, prop.dispatch_count(root)]
bound[29] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", foreground_color_h299, root_ref, w6_ref), foreground_color_h299, [root_ref, w6_ref]]
bound[30] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h300, root_ref, w6_ref), size_hint_y_h300, [root_ref, w6_ref]]
bound[31] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h300, root_ref, w6_ref), size_hint_y_h300, [root_ref, w6_ref]]
bound[32] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h301, root_ref, w6_ref), size_hint_x_h301, [root_ref, w6_ref]]
bound[33] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h301, root_ref, w6_ref), size_hint_x_h301, [root_ref, w6_ref]]
bound[34] = [None, None, None, root_ref, "width", bind("width", height_h302, root_ref, w6_ref), height_h302, [root_ref, w6_ref]]
bound[35] = [None, None, None, root_ref, "height", bind("height", height_h302, root_ref, w6_ref), height_h302, [root_ref, w6_ref]]
bound[36] = [None, None, None, root_ref, "hsv", bind("hsv", color_h303, root_ref, w7_ref), color_h303, [root_ref, w7_ref]]
bound[37] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", foreground_color_h304, root_ref, w7_ref), foreground_color_h304, [root_ref, w7_ref]]
bound[38] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h305, root_ref, w7_ref), size_hint_y_h305, [root_ref, w7_ref]]
bound[39] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h305, root_ref, w7_ref), size_hint_y_h305, [root_ref, w7_ref]]
bound[40] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h306, root_ref, w7_ref), size_hint_x_h306, [root_ref, w7_ref]]
bound[41] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h306, root_ref, w7_ref), size_hint_x_h306, [root_ref, w7_ref]]
bound[42] = [None, None, None, root_ref, "width", bind("width", height_h307, root_ref, w7_ref), height_h307, [root_ref, w7_ref]]
bound[43] = [None, None, None, root_ref, "height", bind("height", height_h307, root_ref, w7_ref), height_h307, [root_ref, w7_ref]]
bound[44] = [None, None, None, root_ref, "hsv", bind("hsv", color_h308, root_ref, w8_ref), color_h308, [root_ref, w8_ref]]
bound[45] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", foreground_color_h309, root_ref, w8_ref), foreground_color_h309, [root_ref, w8_ref]]
bound[46] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h310, root_ref, w8_ref), size_hint_y_h310, [root_ref, w8_ref]]
bound[47] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h310, root_ref, w8_ref), size_hint_y_h310, [root_ref, w8_ref]]
bound[48] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h311, root_ref, w8_ref), size_hint_x_h311, [root_ref, w8_ref]]
bound[49] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h311, root_ref, w8_ref), size_hint_x_h311, [root_ref, w8_ref]]
bound[50] = [None, None, None, root_ref, "width", bind("width", height_h312, root_ref, w8_ref), height_h312, [root_ref, w8_ref]]
bound[51] = [None, None, None, root_ref, "height", bind("height", height_h312, root_ref, w8_ref), height_h312, [root_ref, w8_ref]]
bound[52] = [None, None, None, root_ref, "hsv", bind("hsv", color_h313, root_ref, w9_ref), color_h313, [root_ref, w9_ref]]
bound[53] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", foreground_color_h314, root_ref, w9_ref), foreground_color_h314, [root_ref, w9_ref]]
bound[54] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h315, root_ref, w9_ref), size_hint_y_h315, [root_ref, w9_ref]]
bound[55] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h315, root_ref, w9_ref), size_hint_y_h315, [root_ref, w9_ref]]
bound[56] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h316, root_ref, w9_ref), size_hint_x_h316, [root_ref, w9_ref]]
bound[57] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h316, root_ref, w9_ref), size_hint_x_h316, [root_ref, w9_ref]]
bound[58] = [None, None, None, root_ref, "width", bind("width", height_h317, root_ref, w9_ref), height_h317, [root_ref, w9_ref]]
bound[59] = [None, None, None, root_ref, "height", bind("height", height_h317, root_ref, w9_ref), height_h317, [root_ref, w9_ref]]
bound[60] = [None, None, None, root_ref, "width", bind("width", size_hint_y_h318, root_ref, w10_ref), size_hint_y_h318, [root_ref, w10_ref]]
bound[61] = [None, None, None, root_ref, "height", bind("height", size_hint_y_h318, root_ref, w10_ref), size_hint_y_h318, [root_ref, w10_ref]]
bound[62] = [None, None, None, root_ref, "width", bind("width", size_hint_x_h319, root_ref, w10_ref), size_hint_x_h319, [root_ref, w10_ref]]
bound[63] = [None, None, None, root_ref, "height", bind("height", size_hint_x_h319, root_ref, w10_ref), size_hint_x_h319, [root_ref, w10_ref]]
bound[64] = [None, None, None, root_ref, "width", bind("width", height_h320, root_ref, w10_ref), height_h320, [root_ref, w10_ref]]
bound[65] = [None, None, None, root_ref, "height", bind("height", height_h320, root_ref, w10_ref), height_h320, [root_ref, w10_ref]]
bound[66] = [None, None, None, root_ref, "foreground_color", bind("foreground_color", color_h321, root_ref, w11_ref), color_h321, [root_ref, w11_ref]]
bound[67] = [None, None, None, root_ref, "hex_color", bind("hex_color", text_h322, root_ref, w13_ref), text_h322, [root_ref, w13_ref]]
bound[68] = [None, None, None, root_ref, "color", bind("color", delayed_call_fn, delayed_rgba_h323), delayed_call_fn, (delayed_rgba_h323, )]
bound[69] = [None, None, None, root_ref, "color", bind("color", color_h328, root_ref, w16_wheel_ref), color_h328, [root_ref, w16_wheel_ref]]
_handlers[w13.uid].append((bound, (67, )))
_handlers[w11.uid].append((bound, (66, )))
_handlers[w10.uid].append((bound, (60, 61, 62, 63, 64, 65)))
_handlers[w7.uid].append((bound, (36, 37, 38, 39, 40, 41, 42, 43)))
_handlers[w6.uid].append((bound, (28, 29, 30, 31, 32, 33, 34, 35)))
_handlers[w5.uid].append((bound, (21, 22, 23, 24, 25, 26, 27)))
_handlers[w4.uid].append((bound, (14, 15, 16, 17, 18, 19, 20)))
_handlers[w3.uid].append((bound, (7, 8, 9, 10, 11, 12, 13)))
_handlers[w2.uid].append((bound, (3, 4, 5, 6)))
_handlers[w1.uid].append((bound, (1, 2)))
_handlers[w16_wheel.uid].append((bound, (69, )))
_handlers[g14.uid].append((bound, (68, )))
_handlers[root.uid].append((bound, (0, )))
_handlers[w9.uid].append((bound, (52, 53, 54, 55, 56, 57, 58, 59)))
_handlers[w8.uid].append((bound, (44, 45, 46, 47, 48, 49, 50, 51)))
w10_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w10_ref, "height", w10.fast_bind("height", height_h320, root_ref, w10_ref), height_h320, [root_ref, w10_ref]]
if bound[0][5]:
prop = w10.property("height")
dispatch_objs[5] = [w10, prop, prop.dispatch_count(w10)]
_handlers[w10.uid].append((bound, (0, )))
w16_wheel_bound = bound = [None, ] * 7
bind = w16_wheel.fast_bind
bind("on_color", on_on_color_h17, root_ref)
prop = w16_wheel.property("on_color", quiet=True)
if prop is not None:
dispatch_objs[6] = [w16_wheel, prop, prop.dispatch_count(w16_wheel)]
bound[0] = [None, None, None, w16_wheel_ref, "a", bind("a", foreground_color_h279, root_ref, w16_wheel_ref), foreground_color_h279, [root_ref, w16_wheel_ref]]
bound[1] = [None, None, None, w16_wheel_ref, "r", bind("r", color_h283, w16_wheel_ref, w3_ref), color_h283, [w16_wheel_ref, w3_ref]]
bound[2] = [None, None, None, w16_wheel_ref, "g", bind("g", color_h288, w16_wheel_ref, w4_ref), color_h288, [w16_wheel_ref, w4_ref]]
bound[3] = [None, None, None, w16_wheel_ref, "b", bind("b", color_h293, w16_wheel_ref, w5_ref), color_h293, [w16_wheel_ref, w5_ref]]
bound[4] = [None, None, None, w16_wheel_ref, "center_y", bind("center_y", _origin_h326, w16_wheel_ref), _origin_h326, (w16_wheel_ref, )]
bound[5] = [None, None, None, w16_wheel_ref, "center_x", bind("center_x", _origin_h326, w16_wheel_ref), _origin_h326, (w16_wheel_ref, )]
bound[6] = [None, None, None, w16_wheel_ref, "size", bind("size", _radius_h327, w16_wheel_ref), _radius_h327, (w16_wheel_ref, )]
_handlers[w3.uid].append((bound, (1, )))
_handlers[w5.uid].append((bound, (3, )))
_handlers[w4.uid].append((bound, (2, )))
_handlers[root.uid].append((bound, (0, )))
_handlers[w16_wheel.uid].append((bound, (4, 5, 6)))
w2_bound = bound = [None, ] * 3
bind = w2.fast_bind
bound[0] = [None, None, None, w2_ref, "height", bind("height", height_h282, root_ref, w2_ref), height_h282, [root_ref, w2_ref]]
if bound[0][5]:
prop = w2.property("height")
dispatch_objs[7] = [w2, prop, prop.dispatch_count(w2)]
bound[1] = [None, None, None, w2_ref, "size", bind("size", delayed_call_fn, delayed_size_h324), delayed_call_fn, (delayed_size_h324, )]
bound[2] = [None, None, None, w2_ref, "pos", bind("pos", delayed_call_fn, delayed_pos_h325), delayed_call_fn, (delayed_pos_h325, )]
_handlers[g15.uid].append((bound, (1, 2)))
_handlers[w2.uid].append((bound, (0, )))
w3_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w3_ref, "height", w3.fast_bind("height", height_h287, root_ref, w3_ref), height_h287, [root_ref, w3_ref]]
if bound[0][5]:
prop = w3.property("height")
dispatch_objs[8] = [w3, prop, prop.dispatch_count(w3)]
_handlers[w3.uid].append((bound, (0, )))
w4_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w4_ref, "height", w4.fast_bind("height", height_h292, root_ref, w4_ref), height_h292, [root_ref, w4_ref]]
if bound[0][5]:
prop = w4.property("height")
dispatch_objs[9] = [w4, prop, prop.dispatch_count(w4)]
_handlers[w4.uid].append((bound, (0, )))
w5_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w5_ref, "height", w5.fast_bind("height", height_h297, root_ref, w5_ref), height_h297, [root_ref, w5_ref]]
if bound[0][5]:
prop = w5.property("height")
dispatch_objs[10] = [w5, prop, prop.dispatch_count(w5)]
_handlers[w5.uid].append((bound, (0, )))
w6_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w6_ref, "height", w6.fast_bind("height", height_h302, root_ref, w6_ref), height_h302, [root_ref, w6_ref]]
if bound[0][5]:
prop = w6.property("height")
dispatch_objs[11] = [w6, prop, prop.dispatch_count(w6)]
_handlers[w6.uid].append((bound, (0, )))
w7_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w7_ref, "height", w7.fast_bind("height", height_h307, root_ref, w7_ref), height_h307, [root_ref, w7_ref]]
if bound[0][5]:
prop = w7.property("height")
dispatch_objs[12] = [w7, prop, prop.dispatch_count(w7)]
_handlers[w7.uid].append((bound, (0, )))
w8_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w8_ref, "height", w8.fast_bind("height", height_h312, root_ref, w8_ref), height_h312, [root_ref, w8_ref]]
if bound[0][5]:
prop = w8.property("height")
dispatch_objs[13] = [w8, prop, prop.dispatch_count(w8)]
_handlers[w8.uid].append((bound, (0, )))
w9_bound = bound = [None, ] * 1
bound[0] = [None, None, None, w9_ref, "height", w9.fast_bind("height", height_h317, root_ref, w9_ref), height_h317, [root_ref, w9_ref]]
if bound[0][5]:
prop = w9.property("height")
dispatch_objs[14] = [w9, prop, prop.dispatch_count(w9)]
_handlers[w9.uid].append((bound, (0, )))
w13.fast_bind("on_text", on_on_text_h16, root_ref)
prop = w13.property("on_text", quiet=True)
if prop is not None:
dispatch_objs[15] = [w13, prop, prop.dispatch_count(w13)]
return partial(_d69, w16_wheel_bound, w7_bound, w6_bound, w5_bound, w4_bound, w3_bound, w2_bound, w10_bound, root_bound, w9_bound, w8_bound, dispatch_objs, (w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w16_wheel))
def _d69(w16_wheel_bound, w7_bound, w6_bound, w5_bound, w4_bound, w3_bound, w2_bound, w10_bound, root_bound, w9_bound, w8_bound, dispatch_objs, widgets):
if dispatch_objs[0] is not None:
obj, prop, count = dispatch_objs[0]
prop.dispatch_stale(obj, count)
if dispatch_objs[1] is not None:
obj, prop, count = dispatch_objs[1]
prop.dispatch_stale(obj, count)
if dispatch_objs[2] is not None:
obj, prop, count = dispatch_objs[2]
prop.dispatch_stale(obj, count)
if dispatch_objs[3] is not None:
obj, prop, count = dispatch_objs[3]
prop.dispatch_stale(obj, count)
if dispatch_objs[4] is not None:
obj, prop, count = dispatch_objs[4]
prop.dispatch_stale(obj, count)
if dispatch_objs[5] is not None:
obj, prop, count = dispatch_objs[5]
prop.dispatch_stale(obj, count)
if dispatch_objs[6] is not None:
obj, prop, count = dispatch_objs[6]
prop.dispatch_stale(obj, count)
if dispatch_objs[7] is not None:
obj, prop, count = dispatch_objs[7]
prop.dispatch_stale(obj, count)
if dispatch_objs[8] is not None:
obj, prop, count = dispatch_objs[8]
prop.dispatch_stale(obj, count)
if dispatch_objs[9] is not None:
obj, prop, count = dispatch_objs[9]
prop.dispatch_stale(obj, count)
if dispatch_objs[10] is not None:
obj, prop, count = dispatch_objs[10]
prop.dispatch_stale(obj, count)
if dispatch_objs[11] is not None:
obj, prop, count = dispatch_objs[11]
prop.dispatch_stale(obj, count)
if dispatch_objs[12] is not None:
obj, prop, count = dispatch_objs[12]
prop.dispatch_stale(obj, count)
if dispatch_objs[13] is not None:
obj, prop, count = dispatch_objs[13]
prop.dispatch_stale(obj, count)
if dispatch_objs[14] is not None:
obj, prop, count = dispatch_objs[14]
prop.dispatch_stale(obj, count)
if dispatch_objs[15] is not None:
obj, prop, count = dispatch_objs[15]
prop.dispatch_stale(obj, count)
return widgets
# register dynamic classes
Factory.register("ColorPicker_Input", baseclasses="TextInput")
Factory.register("ColorPicker_Selector", baseclasses="BoxLayout")
Factory.register("ColorPicker_Label", baseclasses="Label")
Factory.register("ActionPreviousImage", baseclasses="Image")
# registration (selector, rule, avoid_previous_rules)
rules = (
(ParserSelectorName("label"), _r0, False),
(ParserSelectorName("button"), _r1, True),
(ParserSelectorName("-togglebutton"), _r1, True),
(ParserSelectorName("bubblecontent"), _r2, False),
(ParserSelectorName("bubblebutton"), _r3, False),
(ParserSelectorName("slider"), _r4, False),
(ParserSelectorName("progressbar"), _r5, False),
(ParserSelectorName("splitterstrip"), _r6, False),
(ParserSelectorName("scatter"), _r7, False),
(ParserSelectorName("relativelayout"), _r8, False),
(ParserSelectorName("image"), _r9, False),
(ParserSelectorName("asyncimage"), _r9, False),
(ParserSelectorName("effectwidget"), _r10, False),
(ParserSelectorName("tabbedpanelcontent"), _r11, False),
(ParserSelectorName("tabbedpanelstrip"), _r12, False),
(ParserSelectorName("striplayout"), _r13, False),
(ParserSelectorName("tabbedpanelheader"), _r14, False),
(ParserSelectorName("selector"), _r15, False),
(ParserSelectorName("textinput"), _r16, False),
(ParserSelectorName("textinputcutcopypaste"), _r17, False),
(ParserSelectorName("codeinput"), _r18, False),
(ParserSelectorName("treeviewnode"), _r19, False),
(ParserSelectorName("treeviewlabel"), _r20, False),
(ParserSelectorName("stencilview"), _r21, False),
(ParserSelectorName("filechooserlistlayout"), _r22, False),
(ParserSelectorName("filechooserlistview"), _r23, False),
(ParserSelectorName("filechoosericonlayout"), _r24, False),
(ParserSelectorName("filechoosericonview"), _r25, False),
(ParserSelectorName("filechooserprogress"), _r26, False),
(ParserSelectorName("switch"), _r27, False),
(ParserSelectorName("modalview"), _r28, False),
(ParserSelectorName("popup"), _r29, False),
(ParserSelectorName("spinneroption"), _r30, False),
(ParserSelectorName("spinner"), _r31, False),
(ParserSelectorName("actionbar"), _r32, False),
(ParserSelectorName("actionview"), _r33, False),
(ParserSelectorName("actionseparator"), _r34, False),
(ParserSelectorName("actionbutton"), _r35, False),
(ParserSelectorName("actiontogglebutton"), _r35, False),
(ParserSelectorName("actiongroup"), _r36, False),
(ParserSelectorName("actioncheck"), _r37, False),
(ParserSelectorName("actionpreviousimage"), _r38, False),
(ParserSelectorName("actionprevious"), _r39, False),
(ParserSelectorName("actiongroup"), _r40, False),
(ParserSelectorName("actionoverflow"), _r41, False),
(ParserSelectorName("actiondropdown"), _r42, False),
(ParserSelectorName("accordionitem"), _r43, False),
(ParserSelectorName("settingspacer"), _r44, False),
(ParserSelectorName("settingitem"), _r45, False),
(ParserSelectorName("settingboolean"), _r46, False),
(ParserSelectorName("settingstring"), _r47, False),
(ParserSelectorName("settingpath"), _r48, False),
(ParserSelectorName("settingoptions"), _r49, False),
(ParserSelectorName("settingtitle"), _r50, False),
(ParserSelectorName("settingsidebarlabel"), _r51, False),
(ParserSelectorName("settingspanel"), _r52, False),
(ParserSelectorName("settings"), _r53, False),
(ParserSelectorName("interfacewithsidebar"), _r54, False),
(ParserSelectorName("interfacewithspinner"), _r55, False),
(ParserSelectorName("menuspinner"), _r56, False),
(ParserSelectorName("menusidebar"), _r57, False),
(ParserSelectorName("contentpanel"), _r58, False),
(ParserSelectorName("interfacewithtabbedpanel"), _r59, False),
(ParserSelectorName("scrollview"), _r60, False),
(ParserSelectorName("videoplayerpreview"), _r61, False),
(ParserSelectorName("videoplayerannotation"), _r62, False),
(ParserSelectorName("videoplayer"), _r63, False),
(ParserSelectorName("checkbox"), _r64, False),
(ParserSelectorName("screenmanager"), _r65, False),
(ParserSelectorName("colorpicker_input"), _r66, False),
(ParserSelectorName("colorpicker_label"), _r67, False),
(ParserSelectorName("colorpicker_selector"), _r68, False),
(ParserSelectorName("colorpicker"), _r69, False),
)
def get_root():
pass
Builder.load_string('''
[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
Label:
id: filename
text_size: self.width, None
halign: 'left'
shorten: True
text: ctx.name
Label:
text_size: self.width, None
size_hint_x: None
halign: 'right'
text: '{}'.format(ctx.get_nice_size())
''')
Builder.load_string('''
[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
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_size: '11sp'
color: .8, .8, .8, 1
size: '100dp', '16sp'
pos: root.pos
halign: 'center'
''')
Builder.load_string('''
[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
''')
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment