Kivy-examples 2.3.1.dev0__py3-none-any.whl

kivy/uix/recycleboxlayout.py

@@ -0,0 +1,183 @@
+"""
+RecycleBoxLayout
+================
+
+.. versionadded:: 1.10.0
+
+.. warning::
+    This module is highly experimental, its API may change in the future and
+    the documentation is not complete at this time.
+
+The RecycleBoxLayout is designed to provide a
+:class:`~kivy.uix.boxlayout.BoxLayout` type layout when used with the
+:class:`~kivy.uix.recycleview.RecycleView` widget. Please refer to the
+:mod:`~kivy.uix.recycleview` module documentation for more information.
+
+"""
+
+from kivy.uix.recyclelayout import RecycleLayout
+from kivy.uix.boxlayout import BoxLayout
+
+__all__ = ('RecycleBoxLayout', )
+
+
+class RecycleBoxLayout(RecycleLayout, BoxLayout):
+
+    _rv_positions = None
+
+    def __init__(self, **kwargs):
+        super(RecycleBoxLayout, self).__init__(**kwargs)
+        self.funbind('children', self._trigger_layout)
+
+    def _update_sizes(self, changed):
+        horizontal = self.orientation == 'horizontal'
+        padding_left, padding_top, padding_right, padding_bottom = self.padding
+        padding_x = padding_left + padding_right
+        padding_y = padding_top + padding_bottom
+        selfw = self.width
+        selfh = self.height
+        layout_w = max(0, selfw - padding_x)
+        layout_h = max(0, selfh - padding_y)
+        cx = self.x + padding_left
+        cy = self.y + padding_bottom
+        view_opts = self.view_opts
+        remove_view = self.remove_view
+
+        for (index, widget, (w, h), (wn, hn), (shw, shh), (shnw, shnh),
+             (shw_min, shh_min), (shwn_min, shhn_min), (shw_max, shh_max),
+             (shwn_max, shhn_max), ph, phn) in changed:
+            if (horizontal and
+                (shw != shnw or w != wn or shw_min != shwn_min or
+                 shw_max != shwn_max) or
+                not horizontal and
+                (shh != shnh or h != hn or shh_min != shhn_min or
+                 shh_max != shhn_max)):
+                return True
+
+            remove_view(widget, index)
+            opt = view_opts[index]
+            if horizontal:
+                wo, ho = opt['size']
+                if shnh is not None:
+                    _, h = opt['size'] = [wo, shnh * layout_h]
+                else:
+                    h = ho
+
+                xo, yo = opt['pos']
+                for key, value in phn.items():
+                    posy = value * layout_h
+                    if key == 'y':
+                        yo = posy + cy
+                    elif key == 'top':
+                        yo = posy - h
+                    elif key == 'center_y':
+                        yo = posy - (h / 2.)
+                opt['pos'] = [xo, yo]
+            else:
+                wo, ho = opt['size']
+                if shnw is not None:
+                    w, _ = opt['size'] = [shnw * layout_w, ho]
+                else:
+                    w = wo
+
+                xo, yo = opt['pos']
+                for key, value in phn.items():
+                    posx = value * layout_w
+                    if key == 'x':
+                        xo = posx + cx
+                    elif key == 'right':
+                        xo = posx - w
+                    elif key == 'center_x':
+                        xo = posx - (w / 2.)
+                opt['pos'] = [xo, yo]
+
+        return False
+
+    def compute_layout(self, data, flags):
+        super(RecycleBoxLayout, self).compute_layout(data, flags)
+
+        changed = self._changed_views
+        if (changed is None or
+                changed and not self._update_sizes(changed)):
+            return
+
+        self.clear_layout()
+        self._rv_positions = None
+        if not data:
+            l, t, r, b = self.padding
+            self.minimum_size = l + r, t + b
+            return
+
+        view_opts = self.view_opts
+        n = len(view_opts)
+        for i, x, y, w, h in self._iterate_layout(
+                [(opt['size'], opt['size_hint'], opt['pos_hint'],
+                  opt['size_hint_min'], opt['size_hint_max']) for
+                 opt in reversed(view_opts)]):
+            opt = view_opts[n - i - 1]
+            shw, shh = opt['size_hint']
+            opt['pos'] = x, y
+            wo, ho = opt['size']
+            # layout won't/shouldn't change previous size if size_hint is None
+            # which is what w/h being None means.
+            opt['size'] = [(wo if shw is None else w),
+                           (ho if shh is None else h)]
+
+        spacing = self.spacing
+        pos = self._rv_positions = [None, ] * len(data)
+
+        if self.orientation == 'horizontal':
+            pos[0] = self.x
+            last = pos[0] + self.padding[0] + view_opts[0]['size'][0] + \
+                spacing / 2.
+            for i, val in enumerate(view_opts[1:], 1):
+                pos[i] = last
+                last += val['size'][0] + spacing
+        else:
+            last = pos[-1] = \
+                self.y + self.height - self.padding[1] - \
+                view_opts[0]['size'][1] - spacing / 2.
+            n = len(view_opts)
+            for i, val in enumerate(view_opts[1:], 1):
+                last -= spacing + val['size'][1]
+                pos[n - 1 - i] = last
+
+    def get_view_index_at(self, pos):
+        calc_pos = self._rv_positions
+        if not calc_pos:
+            return 0
+
+        x, y = pos
+
+        if self.orientation == 'horizontal':
+            if x >= calc_pos[-1] or len(calc_pos) == 1:
+                return len(calc_pos) - 1
+
+            ix = 0
+            for val in calc_pos[1:]:
+                if x < val:
+                    return ix
+                ix += 1
+        else:
+            if y >= calc_pos[-1] or len(calc_pos) == 1:
+                return 0
+
+            iy = 0
+            for val in calc_pos[1:]:
+                if y < val:
+                    return len(calc_pos) - iy - 1
+                iy += 1
+
+        assert False
+
+    def compute_visible_views(self, data, viewport):
+        if self._rv_positions is None or not data:
+            return []
+
+        x, y, w, h = viewport
+        at_idx = self.get_view_index_at
+        if self.orientation == 'horizontal':
+            a, b = at_idx((x, y)), at_idx((x + w, y))
+        else:
+            a, b = at_idx((x, y + h)), at_idx((x, y))
+        return list(range(a, b + 1))

kivy/uix/recyclegridlayout.py

@@ -0,0 +1,255 @@
+"""
+RecycleGridLayout
+=================
+
+.. versionadded:: 1.10.0
+
+.. warning::
+    This module is highly experimental, its API may change in the future and
+    the documentation is not complete at this time.
+
+The RecycleGridLayout is designed to provide a
+:class:`~kivy.uix.gridlayout.GridLayout` type layout when used with the
+:class:`~kivy.uix.recycleview.RecycleView` widget. Please refer to the
+:mod:`~kivy.uix.recycleview` module documentation for more information.
+"""
+
+import itertools
+chain_from_iterable = itertools.chain.from_iterable
+from kivy.uix.recyclelayout import RecycleLayout
+from kivy.uix.gridlayout import GridLayout, GridLayoutException, nmax, nmin
+from collections import defaultdict
+
+__all__ = ('RecycleGridLayout', )
+
+
+class RecycleGridLayout(RecycleLayout, GridLayout):
+
+    _cols_pos = None
+    _rows_pos = None
+
+    def __init__(self, **kwargs):
+        super(RecycleGridLayout, self).__init__(**kwargs)
+        self.funbind('children', self._trigger_layout)
+
+    def on_children(self, instance, value):
+        pass
+
+    def _fill_rows_cols_sizes(self):
+        cols, rows = self._cols, self._rows
+        cols_sh, rows_sh = self._cols_sh, self._rows_sh
+        cols_sh_min, rows_sh_min = self._cols_sh_min, self._rows_sh_min
+        cols_sh_max, rows_sh_max = self._cols_sh_max, self._rows_sh_max
+        self._cols_count = cols_count = [defaultdict(int) for _ in cols]
+        self._rows_count = rows_count = [defaultdict(int) for _ in rows]
+
+        # calculate minimum size for each columns and rows
+        idx_iter = self._create_idx_iter(len(cols), len(rows))
+        has_bound_y = has_bound_x = False
+        for opt, (col, row) in zip(self.view_opts, idx_iter):
+            (shw, shh), (w, h) = opt['size_hint'], opt['size']
+            shw_min, shh_min = opt['size_hint_min']
+            shw_max, shh_max = opt['size_hint_max']
+
+            if shw is None:
+                cols_count[col][w] += 1
+            if shh is None:
+                rows_count[row][h] += 1
+
+            # compute minimum size / maximum stretch needed
+            if shw is None:
+                cols[col] = nmax(cols[col], w)
+            else:
+                cols_sh[col] = nmax(cols_sh[col], shw)
+                if shw_min is not None:
+                    has_bound_x = True
+                    cols_sh_min[col] = nmax(cols_sh_min[col], shw_min)
+                if shw_max is not None:
+                    has_bound_x = True
+                    cols_sh_max[col] = nmin(cols_sh_max[col], shw_max)
+
+            if shh is None:
+                rows[row] = nmax(rows[row], h)
+            else:
+                rows_sh[row] = nmax(rows_sh[row], shh)
+                if shh_min is not None:
+                    has_bound_y = True
+                    rows_sh_min[row] = nmax(rows_sh_min[row], shh_min)
+                if shh_max is not None:
+                    has_bound_y = True
+                    rows_sh_max[row] = nmin(rows_sh_max[row], shh_max)
+        self._has_hint_bound_x = has_bound_x
+        self._has_hint_bound_y = has_bound_y
+
+    def _update_rows_cols_sizes(self, changed):
+        cols_count, rows_count = self._cols_count, self._rows_count
+        cols, rows = self._cols, self._rows
+        remove_view = self.remove_view
+        n_cols = len(cols)
+        n_rows = len(rows)
+        orientation = self.orientation
+
+        # this can be further improved to reduce re-comp, but whatever...
+        for index, widget, (w, h), (wn, hn), sh, shn, sh_min, shn_min, \
+                sh_max, shn_max, _, _ in changed:
+            if sh != shn or sh_min != shn_min or sh_max != shn_max:
+                return True
+            elif (sh[0] is not None and w != wn and
+                  (h == hn or sh[1] is not None) or
+                  sh[1] is not None and h != hn and
+                  (w == wn or sh[0] is not None)):
+                remove_view(widget, index)
+            else:  # size hint is None, so check if it can be resized inplace
+                col, row = self._calculate_idx_from_a_view_idx(
+                    n_cols, n_rows, index)
+                if w != wn:
+                    col_w = cols[col]
+                    cols_count[col][w] -= 1
+                    cols_count[col][wn] += 1
+                    was_last_w = cols_count[col][w] <= 0
+                    if was_last_w and col_w == w or wn > col_w:
+                        return True
+                    if was_last_w:
+                        del cols_count[col][w]
+
+                if h != hn:
+                    row_h = rows[row]
+                    rows_count[row][h] -= 1
+                    rows_count[row][hn] += 1
+                    was_last_h = rows_count[row][h] <= 0
+                    if was_last_h and row_h == h or hn > row_h:
+                        return True
+                    if was_last_h:
+                        del rows_count[row][h]
+
+        return False
+
+    def compute_layout(self, data, flags):
+        super(RecycleGridLayout, self).compute_layout(data, flags)
+
+        n = len(data)
+        smax = self.get_max_widgets()
+        if smax and n > smax:
+            raise GridLayoutException(
+                'Too many children ({}) in GridLayout. Increase rows/cols!'.
+                format(n))
+
+        changed = self._changed_views
+        if (changed is None or
+                changed and not self._update_rows_cols_sizes(changed)):
+            return
+
+        self.clear_layout()
+        if not self._init_rows_cols_sizes(n):
+            self._cols_pos = None
+            l, t, r, b = self.padding
+            self.minimum_size = l + r, t + b
+            return
+        self._fill_rows_cols_sizes()
+        self._update_minimum_size()
+        self._finalize_rows_cols_sizes()
+
+        view_opts = self.view_opts
+        for widget, x, y, w, h in self._iterate_layout(n):
+            opt = view_opts[n - widget - 1]
+            shw, shh = opt['size_hint']
+            opt['pos'] = x, y
+            wo, ho = opt['size']
+            # layout won't/shouldn't change previous size if size_hint is None
+            # which is what w/h being None means.
+            opt['size'] = [(wo if shw is None else w),
+                           (ho if shh is None else h)]
+
+        spacing_x, spacing_y = self.spacing
+        cols, rows = self._cols, self._rows
+
+        cols_pos = self._cols_pos = [None, ] * len(cols)
+        rows_pos = self._rows_pos = [None, ] * len(rows)
+
+        cols_pos[0] = self.x
+        last = cols_pos[0] + self.padding[0] + cols[0] + spacing_x / 2.
+        for i, val in enumerate(cols[1:], 1):
+            cols_pos[i] = last
+            last += val + spacing_x
+
+        last = rows_pos[-1] = \
+            self.y + self.height - self.padding[1] - rows[0] - spacing_y / 2.
+        n = len(rows)
+        for i, val in enumerate(rows[1:], 1):
+            last -= spacing_y + val
+            rows_pos[n - 1 - i] = last
+
+    def get_view_index_at(self, pos):
+        if self._cols_pos is None:
+            return 0
+
+        x, y = pos
+        col_pos = self._cols_pos
+        row_pos = self._rows_pos
+        cols, rows = self._cols, self._rows
+        if not col_pos or not row_pos:
+            return 0
+
+        if x >= col_pos[-1]:
+            ix = len(cols) - 1
+        else:
+            ix = 0
+            for val in col_pos[1:]:
+                if x < val:
+                    break
+                ix += 1
+
+        if y >= row_pos[-1]:
+            iy = len(rows) - 1
+        else:
+            iy = 0
+            for val in row_pos[1:]:
+                if y < val:
+                    break
+                iy += 1
+
+        if not self._fills_from_left_to_right:
+            ix = len(cols) - ix - 1
+        if self._fills_from_top_to_bottom:
+            iy = len(rows) - iy - 1
+        return (iy * len(cols) + ix) if self._fills_row_first else \
+            (ix * len(rows) + iy)
+
+    def compute_visible_views(self, data, viewport):
+        if self._cols_pos is None:
+            return []
+        x, y, w, h = viewport
+        right = x + w
+        top = y + h
+        at_idx = self.get_view_index_at
+        tl, tr, bl, br = sorted((
+            at_idx((x, y)),
+            at_idx((right, y)),
+            at_idx((x, top)),
+            at_idx((right, top)),
+        ))
+
+        n = len(data)
+        if len({tl, tr, bl, br}) < 4:
+            # visible area is one row/column
+            return range(min(n, tl), min(n, br + 1))
+        indices = []
+        stride = len(self._cols) if self._fills_row_first else len(self._rows)
+        if stride:
+            x_slice = br - bl + 1
+            indices = chain_from_iterable(
+                range(min(s, n), min(n, s + x_slice))
+                for s in range(tl, bl + 1, stride))
+        return indices
+
+    def _calculate_idx_from_a_view_idx(self, n_cols, n_rows, view_idx):
+        '''returns a tuple of (column-index, row-index) from a view-index'''
+        if self._fills_row_first:
+            row_idx, col_idx = divmod(view_idx, n_cols)
+        else:
+            col_idx, row_idx = divmod(view_idx, n_rows)
+        if not self._fills_from_left_to_right:
+            col_idx = n_cols - col_idx - 1
+        if not self._fills_from_top_to_bottom:
+            row_idx = n_rows - row_idx - 1
+        return (col_idx, row_idx, )