We Keep Coding

Kivy: Updating Line in KV Lang from Python Code

I cannot seem to get the canvas line to update when the button is pressed and the data is updated. The online guide only shows the kv lang side of this issue, so I am presuming the issue lies in the python code.
this is the kv lang:
<Screen>:
canvas:
Color:
rgba: 1, .3, .8, .5
Line:
points: self.data
Button:
text: 'Generate'
size_hint: (0.15, 0.1)
pos_hint: {'x':0.4, 'y':0.4}
on_press: root.btn()
this is the python code:
import kivy
from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
kivy.require('1.11.1')
class Screen(FloatLayout):
data = []
def __init__(self, i=0, data=[0, 0, 0, 0]):
super().__init__()
self.i = i
Screen.data = data
def btn(self):
print('Generate')
Screen.data = [10*self.i, 10*self.i, 100*self.i, 100*self.i]
self.i = self.i + 1
print(Screen.data)
class MyApp(App):
def build(self):
return Screen()
if __name__ == "__main__":
MyApp().run()

In order for the Line to update whenever the points are updated, you need make it a ListProperty, like this:
class Screen(FloatLayout):
data = ListProperty([])
def __init__(self, i=0, data=[0, 0, 0, 0]):
super().__init__()
self.i = i
def btn(self):
print('Generate')
self.data = [10*self.i, 10*self.i, 100*self.i, 100*self.i]
self.i = self.i + 1
print(self.data)
And you must refer to it as self.data, not Screen.data, because it is a property of the instance.

Display an image partially using stencilview

I have asked a question about making a progress bar using stencilview here
And I could make one successfully.
Now I am trying to make a partially displaying image display as below
First showing background image.
Progressively display certain part of filled image.
For example, fill up the arm then fill up the leg.
In this case, I am trying to fill up depending on which arm and leg parameter is inserted.
I am thinking maybe I should device the images as 5 parts and have stencilview for each of them, but I am asking if there is a way of doing it without putting 5 different images and stencilviews.
Here is what I've currently done for a single progress image.
from kivy.app import App
from kivy.properties import StringProperty, NumericProperty
from kivy.uix.floatlayout import FloatLayout
from kivy.lang.builder import Builder
from kivy.clock import Clock
class CLS_PROGRESS_IMAGE(FloatLayout):
background = StringProperty(None)
progress_image = StringProperty(None)
max = NumericProperty(0.0)
def __init__(self, font_size=20, **kwargs):
super(CLS_PROGRESS_IMAGE, self).__init__(**kwargs)
self.progress_event = None
self.font_size = font_size
self.firstDraw = True
self.pbi = None
self.rect = None
self.bgi = None
self.value = 0.0
self.value_normalized = 0.0
self.horizontal = False
self.looping = True
self.progress_event = Clock.schedule_interval(self._progress, 0.1)
def draw(self):
if self.firstDraw:
self.ids.bgi.source=self.background
self.ids.pbi.source = self.progress_image
self.ids.lab.font_size = self.font_size
self.ids.lab.text = str(int(self.value_normalized*100)) + "%"
self.ids.sten.pos = self.pos
if self.horizontal is True:
self.ids.sten.width = self.size[0]*self.value_normalized
self.ids.sten.height = self.size[1]
else:
self.ids.sten.height= self.size[1]*self.value_normalized
self.ids.sten.width = self.size[0]
self.firstDraw = False
else:
self.ids.sten.pos = self.pos
self.ids.lab.text = str(int(self.value_normalized*100)) + "%"
if self.horizontal is True:
self.ids.sten.width = self.size[0]*self.value_normalized
else:
self.ids.sten.height= self.size[1]*self.value_normalized
def set_value(self, value):
self.value = value
self.value_normalized = self.value / self.max
self.draw()
def _progress(self, dt):
if self.value < self.max - 1:
self.set_value(self.value + 1)
else:
if self.looping:
self.value = 0
self.set_value(self.value)
else:
self.set_value(self.max)
self.progress_event.cancel()
# Demo
class DemoApp(App):
def build(self):
kv = Builder.load_string('''
<CLS_PROGRESS_IMAGE>:
Image:
id: bgi
allow_stretch: True
keep_ratio: False
StencilView:
id: sten
horizontal: False
size_hint: (None, None)
size: (0, root.height) if self.horizontal else (root.width, 0)
Image:
id: pbi
allow_stretch: True
keep_ratio: False
size_hint: (None, None)
size: (root.width, root.height)
pos: (root.pos[0], root.pos[1])
Label:
id: lab
text: '0%'
size_hint: (None, None)
size: self.texture_size
pos_hint: {'center_x': 0.5, 'center_y': 0.5}
CLS_PROGRESS_IMAGE:
size_hint: (None, None)
height: 100
width: 500
max: 100
background: '../images/empty.png'
progress_image: '../images/filled.png'
''')
return kv
if __name__ == '__main__':
DemoApp().run()

Though this is not "partially" progressing an image,
but I could successfully emulate this by just using multiple different images.
Basically, what I've done was progressing images that look like they are partially loaded
and continue the same progressing until I use up all the images I put in a list.
class CLS_PROGRESS_BODY(CLS_PROGRESS_IMAGE):
def __init__(self, **kwargs):
super(CLS_PROGRESS_BODY, self).__init__(**kwargs)
self.percentage_show = False
self.image_list = None
self.apply_adjustment = True
self.progress_event.cancel()
self.limitation = 0
def start_progress(self):
self.firstDraw = True
self.progress_event.cancel()
self.background= '../images/progress0.png'
self.progress_image= '../images/progress1.png'
self.image_list= ['../images/progress2.png', '../images/progress3.png', '../images/progress4.png',
'../images/progress5.png']
if self.apply_adjustment:
self.adjust_progress_position(self.progress_image)
else:
self.set_value(0)
self.limitation = self.max * 0.8
self.progress_event = Clock.schedule_interval(partial(self._progress, self.limitation), 0.1)
def set_image_list(self, list_of_path):
self.image_list = list_of_path
def _progress(self, limit, dt):
if self.value < self.max - 1 and self.value < limit:
self.set_value(self.value + 1)
else:
self.set_value(self.max)
self.progress_event.cancel()
self.load_next_image()
def load_next_image(self):
if self.image_list:
self.ids.bgi.source = self.ids.pbi.source
self.ids.pbi.source = self.image_list.pop(0)
if self.apply_adjustment:
self.adjust_progress_position(self.ids.pbi.source)
else:
self.set_value(0)
self.progress_event = Clock.schedule_interval(partial(self._progress, self.limitation), 0.1)
else:
if self.looping:
self.start_progress()

Why is Image not shown properly as a Button background in Kivy?

I'm trying to convert this kv code into my own class
<BaseScreen>: # This is GridLayout
cols: 4
rows: 4
padding: 25
Button:
size_hint_x: None
size_hint_y: None
Image:
source: "business_bookcover.png"
x: self.parent.x
y: self.parent.y
width: self.parent.width
height: self.parent.height
keep_ratio: False
The problem is that I'm trying to make "clickable image", but when I append widget to the button, image is on the default position (0,0), totally out of the button position. Is there any workaround how to do it?
This is my try
class Book(Button):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.size_hint = (None, None)
book_cover_image_source = kwargs.get('cover') or BLANK_BOOK_COVER
book_cover = Image(source=book_cover_image_source)
book_cover.pos = self.pos
book_cover.width = self.width
book_cover.height = self.height
book_cover.allow_stretch = True
book_cover.keep_ratio = False
self.add_widget(book_cover)

In kv languaje properties used in the expression (x:, y:, width:) will be observed. When the parent's size/pos change, child widget change accordingly. You must suply this event bindings in the Python class:
class Book(Button):
def __init__(self, cover=BLANK_BOOK_COVER, **kwargs):
super(Book, self).__init__(**kwargs)
self.size_hint = (None, None)
self.book_cover = Image(source=cover)
self.book_cover.allow_stretch = True
self.book_cover.keep_ratio = False
self.add_widget(self.book_cover)
def on_size(self, *args):
self.book_cover.size = self.size
def on_pos(self, *args):
self.book_cover.pos = self.pos
A simpler option to get a clickable image is to have your class Book inherit from ButtonBehabior and Image classes:
from kivy.uix.behaviors import ButtonBehavior
from kivy.uix.image import Image
class Book(ButtonBehavior, Image):
def __init__(self, cover=BLANK_BOOK_COVER, **kwargs):
super(Book, self).__init__(**kwargs)
self.source = cover
self.size_hint = (None, None)
self.allow_stretch = True
self.keep_ratio = False

usage of DragBehavior in Kivy

I'm new for python and kivy, and struggling with them.
I wanted to implement drag and drop function (a function that when a image is dragged to another image and dropped on it, do something.) with kivy.
What I want to do are the following three things;
know the id of the element that the user has been holding now.
know the id of the element that the user is on hover.
know the id of the element which was under the pointer when the user has dropped what he had.
I thought this would be useful to deal with them, so I wrote down the python script and .kivy file following. However, it dosen't work as I intended.
there are many problems which I don't know how to solve;
print(self.id) returns None.
Even though I am dragging only 1 element, on_touch_up prints None twice.
once you dragged and dropped a image, the image cannot be dragged anymore.
python file:
from kivy.app import App
from kivy.uix.image import Image
from kivy.uix.behaviors import DragBehavior
from kivy.properties import BooleanProperty
from kivy.properties import ObjectProperty
from kivy.factory import Factory
from kivy.core.window import Window
class HoverBehavior(object):
"""Hover behavior.
:Events:
`on_enter`
Fired when mouse enter the bbox of the widget.
`on_leave`
Fired when the mouse exit the widget
"""
hovered = BooleanProperty(False)
border_point = ObjectProperty(None)
'''Contains the last relevant point received by the Hoverable. This can
be used in `on_enter` or `on_leave` in order to know where was dispatched the event.
'''
def __init__(self, **kwargs):
self.register_event_type('on_enter')
self.register_event_type('on_leave')
Window.bind(mouse_pos=self.on_mouse_pos)
super(HoverBehavior, self).__init__(**kwargs)
def on_mouse_pos(self, *args):
if not self.get_root_window():
return # do proceed if I'm not displayed <=> If have no parent
pos = args[1]
# Next line to_widget allow to compensate for relative layout
inside = self.collide_point(*self.to_widget(*pos))
if self.hovered == inside:
# We have already done what was needed
return
self.border_point = pos
self.hovered = inside
if inside:
self.dispatch('on_enter')
else:
self.dispatch('on_leave')
def on_enter(self):
pass
def on_leave(self):
pass
Factory.register('HoverBehavior', HoverBehavior)
class DraggableImage(DragBehavior, HoverBehavior, Image):
def __init__(self, **args):
super(DraggableImage, self).__init__(**args)
self.source_file = ""
self.is_on_hover = False
def on_enter(self):
self.source_file = self.source
self.source = "green.png"
self.is_on_hover = True
print(self.id)
def on_leave(self):
self.source = self.source_file
self.is_on_hover = False
print(self.id)
def on_touch_up(self, touch):
if self.is_on_hover:
print(self.id)
class TestApp(App):
def build(self):
pass
if __name__ == '__main__':
TestApp().run()
test.kivy:
<DraggableImage>
drag_rectangle: self.x, self.y, self.width, self.height
drag_timeout: 10000000
drag_distance: 0
BoxLayout:
orientation: "horizontal"
DraggableImage:
id: "left_left"
source: "red.png"
DraggableImage:
id: "left_right"
source: "yellow.png"
DraggableImage:
id: "right_left"
source: "red.png"
DraggableImage:
id: "right_right"
source: "yellow.png"

Create a StringProperty named, name for example. Don't use id, because id is used in kv.
Change your class and kv as so:
from kivy.properties import StringProperty
class DraggableImage(DragBehavior, HoverBehavior, Image):
name = StringProperty("")
def __init__(self, **args):
super(DraggableImage, self).__init__(**args)
self.source_file = ""
self.is_on_hover = False
def on_enter(self):
self.source_file = self.source
self.source = "green.png"
self.is_on_hover = True
print(self.name)
def on_leave(self):
self.source = self.source_file
self.is_on_hover = False
print(self.name)
def on_touch_up(self, touch):
if self.is_on_hover:
print(self.name)
KV = """
<DraggableImage>:
drag_rectangle: self.x, self.y, self.width, self.height
drag_timeout: 10000000
drag_distance: 0
BoxLayout:
orientation: "horizontal"
DraggableImage:
name: "left_left"
source: "red.png"
DraggableImage:
name: "left_right"
source: "yellow.png"
DraggableImage:
name: "right_left"
source: "red.png"
DraggableImage:
name: "right_right"
source: "yellow.png"
"""

How to trigger an action once on overscroll in Kivy?

I have a ScrollView that's supposed to have an update feature when you overscroll to the top (like in many apps). I've found a way to trigger it when the overscroll exceeds a certain threshold, but it triggers it a lot of times, as the on_overscroll event is triggered on every movement. So is there a way to limit it?
My code looks like this:
from kivy.app import App
from kivy.uix.scrollview import ScrollView
from kivy.uix.gridlayout import GridLayout
from kivy.uix.button import Button
from kivy.effects.dampedscroll import DampedScrollEffect
class Effect(DampedScrollEffect):
def on_overscroll(self, *args):
super().on_overscroll(*args)
if self.overscroll < -50:
print('hey')
class TestApp(App):
def build(self):
sv = ScrollView(effect_cls = Effect,
size_hint_y = 0.2)
gl = GridLayout(cols = 1,
size_hint_y = None)
gl.bind(minimum_height = gl.setter('height'))
for i in range(5):
gl.add_widget(Button(text = str(i),
size_hint = (None, None)))
sv.add_widget(gl)
return sv
TestApp().run()
So, as you can see, when the overscroll goes beyond 50, it prints a simple message. But when you actually try it, you'll see that it prints it many times. What I want for it is to trigger an event, stay untriggerable for some time (like a second) and update the content. I've tried messing with boolean flags and Clock, but it didn't work. What could be done here?

I would use a stateful decorator here:
class call_control:
def __init__(self, max_call_interval):
self._max_call_interval = max_call_interval
self._last_call = time()
def __call__(self, function):
def wrapped(*args, **kwargs):
now = time()
if now - self._last_call > self._max_call_interval:
self._last_call = now
function(*args, **kwargs)
return wrapped
class Effect(DampedScrollEffect):
def on_overscroll(self, *args):
super().on_overscroll(*args)
if self.overscroll < -50:
self.do_something()
#call_control(max_call_interval=1)
def do_something(self):
print('hey')

I know this an old question but someone might find it useful
This is a sample from tshirtman's github gist
from threading import Thread
from time import sleep
from kivy.app import App
from kivy.lang import Builder
from kivy.factory import Factory
from kivy.clock import mainthread
from kivy.properties import ListProperty, BooleanProperty
KV = '''
FloatLayout:
Label:
opacity: 1 if app.refreshing or rv.scroll_y > 1 else 0
size_hint_y: None
pos_hint: {'top': 1}
text: 'Refreshing…' if app.refreshing else 'Pull down to refresh'
RecycleView:
id: rv
data: app.data
viewclass: 'Row'
do_scroll_y: True
do_scroll_x: False
on_scroll_y: app.check_pull_refresh(self, grid)
RecycleGridLayout:
id: grid
cols: 1
size_hint_y: None
height: self.minimum_height
default_size: 0, 36
default_size_hint: 1, None
<Row#Label>:
_id: 0
text: ''
canvas:
Line:
rectangle: self.pos + self.size
width: 0.6
'''
class Application(App):
data = ListProperty([])
refreshing = BooleanProperty()
def build(self):
self.refresh_data()
return Builder.load_string(KV)
def check_pull_refresh(self, view, grid):
max_pixel = 200
to_relative = max_pixel / (grid.height - view.height)
if view.scroll_y < 1.0 + to_relative or self.refreshing:
return
self.refresh_data()
def refresh_data(self):
Thread(target=self._refresh_data).start()
def _refresh_data(self):
self.refreshing = True
sleep(2)
self.append_data([
{'_id': i, 'text': 'hello {}'.format(i)}
for i in range(len(self.data), len(self.data) + 50)
])
self.refreshing = False
#mainthread
def append_data(self, data):
self.data = self.data + data
if __name__ == "__main__":
Application().run()