Created
May 27, 2015 21:08
-
-
Save matham/f7ce6e32ecf5c75c4e68 to your computer and use it in GitHub Desktop.
compiler
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # -*- 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