I want to create a scrollable horizontal box layout where a picture would be in front and if you scroll to the left the next picture would show and it continues like that but im having issues all the pictures are just in the front screen and there is no scrollable effects im tried different methods but to know avail. if someone could solve this for me i would appreciate it below is a sample of my code
Here is the BoxLayout
class PictureLayout(BoxLayout):
def __init__(self, **kwargs):
super(PictureLayout, self).__init__(**kwargs)
self.orientation = "horizontal"
self.height = self.minimum_height
self.spacing = 20
self.padding = [10, 10]
self.size_hint_y = 1
Here are the images
class ProfileWindow(Screen):
def __init__(self, **kwargs):
super(ProfileWindow, self).__init__(**kwargs)
self.scrollview = ScrollView(pos_hint = {"center_x": 0.5, "center_y": 0.5}, size_hint = (1, 0.8))
self.add_widget(self.scrollview)
self.stack = PictureLayout()
self.scrollview.add_widget(self.stack)
self.sampleimage = ImageButton(source="icons/addimage.png",
size_hint=(0.9, None))
self.sampleimage.bind(on_release=self.sampleimagechange)
self.stack.add_widget(self.sampleimage)
self.sampleimage2 = ImageButton(source="icons/addimage.png",
size_hint=(0.9, None))
self.sampleimage2.bind(on_release=self.sampleimagechange2)
self.stack.add_widget(self.sampleimage2)
self.sampleimage3 = ImageButton(source="icons/addimage.png",
size_hint=(0.9, None))
self.sampleimage3.bind(on_release=self.sampleimagechange3)
self.stack.add_widget(self.sampleimage3)
self.sampleimage4 = ImageButton(source="icons/addimage.png",
size_hint=(0.9, None))
self.sampleimage4.bind(on_release=self.sampleimagechange4)
self.stack.add_widget(self.sampleimage4)
self.sampleimage6 = ImageButton(source="icons/addimage.png",
size_hint=(0.9, None))
self.sampleimage6.bind(on_release=self.sampleimagechange6)
self.stack.add_widget(self.sampleimage6)
You must set the width of the PictureLayout to something larger than the width of the ScrollView. For example, the following will work:
class PictureLayout(BoxLayout):
def __init__(self, **kwargs):
super(PictureLayout, self).__init__(**kwargs)
self.orientation = "horizontal"
self.spacing = 20
self.padding = [10, 10]
self.size_hint_y = 1
self.size_hint_x = None
self.width = 3000
A better approach would be to use the kv language:
class PictureLayout(BoxLayout):
pass
kv = '''
ProfileWindow:
name: 'profile'
<PictureLayout>:
orientation: "horizontal"
spacing: 20
padding: [10, 10]
size_hint_x: None
width: self.minimum_width
'''
class HSApp(App):
def build(self):
return Builder.load_string(kv)
This uses the minimum_width property of a BoxLayout, but for this to work, you must set the size of each ImageButton (setting size_hint will not work). Note that using self.minimum_height or self.minimum_width in python code uses the value of that property at the time that the python code is executed. Using that same property in kv (as width: self.minimum_width) also sets up a binding, so that when minimum_width of the PictureLayout changes, its width will also change
I'm very new to Kivy, and even python so I dont have the best of skills. I have a .py file to run everything from my .kv file. I want to add an effect where a widget is highlighted when you hover on it. I found some stuff on github, changed it up to what I want but I cant figure out how to put it in my original and make it work for what I already had. So basically I need help putting the hover stuff into my python file. Its probably an easy answer but again, I'm new to this...
The stuff I need to put into the file...
class HoverBehavior(object):
hovered = BooleanProperty(False)
border_point = ObjectProperty(None)
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
Factory.register('HoverBehavior', HoverBehavior)
class HoverLabel(Label, HoverBehavior):
def on_enter(self, *args):
pass
def on_leave(self, *args):
pass
Builder.load_string('''
<HoverLabel>:
text: "inside"
pos: 200,200
size_hint: None, None
size: 100, 30
canvas.before:
Color:
rgb: 1,0,1 if self.hovered else 0,0,0
Rectangle:
size: self.size
pos: self.pos
''')
if __name__ == '__main__':
fl = FloatLayout()
fl.add_widget(HoverLabel())
runTouchApp(fl)
And my python file:
class VgxMainScreen(Widget):
pass
class VgxUI(Widget):
pass
class CanvasWidget(ButtonBehavior, Label):
pass
class KivyGuiApp(App):
def build(self):
return VgxUI()
if __name__ == '__main__':
KivyGuiApp().run()
Here is a "somewhat" more organized code of your example (plus some things you missed from the original code)
class HoverBehavior(object):
hovered = BooleanProperty(False)
border_point = ObjectProperty(None)
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:
return # We have already done what was needed
self.border_point = pos
self.hovered = inside
if inside:
self.dispatch("on_enter")
else:
self.dispatch("on_leave")
Factory.register('HoverBehavior', HoverBehavior)
Builder.load_string("""
<VgxMainScreen>:
HoverLabel:
text: "1st label"
pos: 200,200
HoverLabel:
text: "2nd label"
pos: 400,200
<HoverLabel>:
text: "inside"
size_hint: None, None
size: 100, 30
canvas.before:
Color:
rgb: 1,0,1 if self.hovered else 0,0,0
Rectangle:
size: self.size
pos: self.pos
""")
class HoverLabel(HoverBehavior, Label):
def on_enter(self, *args):
pass
def on_leave(self, *args):
pass
class VgxMainScreen(Widget):
pass
class KivyGuiApp(App):
def build(self):
return VgxMainScreen()
if __name__ == '__main__':
KivyGuiApp().run()
If your HoverLabel code is in a file named hoverlabel.py in the same folder as your current python file, you can just add:
from hoverlabel import HoverLabel
at the top of your python file.
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()
Immediately after the super() function is called, it creates a duplicate WidgetClass instance.
My understanding of the super() I've used is that it refers to the EditImageLayout class to inherit from. To this end I've tried to implement different variations of the super() but admittedly I'm only guessing at this stage.
Updated to full working, I've cut out a few hundred lines
Run as > OK > Select an Image > Open > Crop (dual instances start running here)
App_R3App.py
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.floatlayout import FloatLayout
from kivy.lang import Builder
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.widget import Widget
from kivy.graphics import Line, Color
from kivy.properties import NumericProperty, ObjectProperty, StringProperty, ListProperty
from kivy.uix.image import Image
import io
from kivy.core.image import Image as CoreImageKivy
from kivy.uix.bubble import Bubble
from kivy.core.window import Window
__version__ = '0.1'
class FirstScreen(Screen):
pass
class SecondScreen(Screen):
def hl(self, image_address):
self.new_image_address = image_address # for the sake of this
self.callback_image(self.new_image_address, image_address, "Auto-cropped image")
def callback_image(self, new_image_address_tmp, image_address_tmp, title):
if new_image_address_tmp:
third_screen = self.manager.get_screen("_third_screen_")
new_image_address_tmp = [k.replace("\\", "/") for k in new_image_address_tmp]
third_screen.callback_image(new_image_address_tmp[0], image_address_tmp[0], title)
class ThirdScreen(Screen, BoxLayout):
# class attribute references
image_size = (0, 0)
image_pos = (0, 0)
image_address = ""
new_image_address = ""
title = "Upload"
rect_box = ObjectProperty(None)
t_x = NumericProperty(0.0)
t_y = NumericProperty(0.0)
x1 = y1 = x2 = y2 = NumericProperty(0.0)
def __init__(self, **kwargs):
super(ThirdScreen, self).__init__(**kwargs)
pass
def callback_image(self, new_image_address, image_address, title):
sm.current = "_third_screen_"
self.new_image_address = new_image_address
self.image_address = image_address
self.title = title
self.ids.main_image.source = self.new_image_address
self.ids.main_title.text = self.title
def enable_cropping(self):
# overwrite class attributes
ThirdScreen.image_address = self.image_address
ThirdScreen.new_image_address = self.new_image_address
print("enable_cropping")
sm.current = "_edit_image_screen_"
return True
class EditImageScreen(Screen):
def __init__(self, **kwargs):
print("EditImageScreen")
super(EditImageScreen, self).__init__(**kwargs)
self.layout = None
def on_pre_enter(self):
print("on_pre_enter")
self.layout = EditImageLayout()
self.add_widget(self.layout)
class EditImageLayout(FloatLayout):
color_button = ListProperty([1, .3, .4, 1])
button_color = ListProperty([0, 0, 0, 1])
rectangle_selector = ObjectProperty()
text_size_rectangle = ObjectProperty()
image_layout = ObjectProperty()
bubble_buttons = ObjectProperty()
bubble_buttons_undo_confirm = ObjectProperty()
def __init__(self, **kwargs):
print("EditImageLayout")
self.sm = kwargs.pop('sm', None)
self.crop_image_screen = kwargs.pop('crop_image_screen', None)
# This is where the problem occurs
super(EditImageLayout, self).__init__(**kwargs)
self.rectangle_selector.bind(size_selected=self.on_change_size_rectangle_selector)
self.rectangle_selector.bind(size_selected_temp=self.update_text_size_rectangle)
self.bind(on_touch_down=self.bubble_buttons.hide)
self.bubble_buttons.resize_button.bind(on_press=self.on_press_resize_button)
self.bubble_buttons_undo_confirm.undo_button.bind(on_press=self.on_press_undo_button)
self.bubble_buttons_undo_confirm.confirm_button.bind(on_press=self.on_press_confirm_button)
def on_change_size_rectangle_selector(self, instance, size_selected):
print("on_change_size_rectangle_selector")
if not self.rectangle_selector.tap_not_draw_a_line():
self.bubble_buttons.show()
else:
self.text_size_rectangle.text = ''
def on_press_resize_button(self, instance):
print("on_press_resize_button")
self.image_layout.resize_image(width=self.rectangle_selector.size_selected[0],
height=self.rectangle_selector.size_selected[1])
self.rectangle_selector.delete_line()
self.text_size_rectangle.text = ''
self.bubble_buttons_undo_confirm.show()
def on_press_undo_button(self, instance):
print("on_press_undo_button")
size = self.image_layout.old_size
self.image_layout.resize_image(width=size[0], height=size[1])
self.bubble_buttons_undo_confirm.hide()
def on_press_confirm_button(self, instance):
print("on_press_confirm_button")
self.bubble_buttons_undo_confirm.hide()
def update_text_size_rectangle(self, instance, size):
print("update_text_size_rectangle")
self.text_size_rectangle.text = str('({0}, {1})'.format(int(size[0]), int(size[1])))
class ImageLayout(Image):
image = ObjectProperty()
path_image = StringProperty('image_tmp.jpg')
path_image_tmp = StringProperty('image_tmp.jpg')
old_size = ListProperty([0, 0])
def __init__(self, **kwargs):
print("ImageLayout")
super(ImageLayout, self).__init__(**kwargs)
self.path_image = ThirdScreen.image_address
self.image = CoreImage(self.path_image,
data=io.BytesIO(open(self.path_image, "rb").read()),
ext=self.path_image[self.path_image.rfind('.') + 1::])
self.source = self.path_image
def resize_image(self, width, height, pos_x=None, pos_y=None):
pos_x, pos_y = abs(Window.width - width)/2 , abs(Window.height - height)/2
self.image.resize(self.path_image,
self.path_image_tmp,
int(width),
int(height))
self.source = self.path_image_tmp
self.pos = pos_x, pos_y
self.old_size = self.size
self.size = width, height
self.reload()
class CoreImage(CoreImageKivy):
def __init__(self, arg, **kwargs):
print("CoreImage")
super(CoreImage, self).__init__(arg, **kwargs)
def resize(self, fname, fname_scaled, width, height):
try:
img = Image.open(fname)
except Exception as e:
print('Exception: ', e)
return
img = img.resize((width, height), Image.ANTIALIAS)
try:
img.save(fname_scaled)
except Exception as e:
print('Exception: ', e)
return
class TouchSelector(Widget):
# Points of Line object
Ax = NumericProperty(0)
Ay = NumericProperty(0)
Bx = NumericProperty(0)
By = NumericProperty(0)
Cx = NumericProperty(0)
Cy = NumericProperty(0)
Dx = NumericProperty(0)
Dy = NumericProperty(0)
# Object line
line = ObjectProperty()
# List of line objects drawn
list_lines_in_image = ListProperty([])
# Size of the selected rectangle
size_selected = ListProperty([0, 0])
# Size previous of the selected rectangle
size_selected_previous = ListProperty([0, 0])
# Size temporary of the selected rectangle
size_selected_temp = ListProperty([0, 0])
# Line Color and width
line_color = ListProperty([0.2, 1, 1, 1])
line_width = NumericProperty(1)
# First tap in TouchSelector
first_tap = True
def __init__(self, *args, **kwargs):
super(TouchSelector, self).__init__(*args, **kwargs)
self.bind(list_lines_in_image=self.remove_old_line)
def on_touch_up(self, touch): # on button up
self.size_selected = abs(self.Cx - self.Dx), abs(self.Cy - self.By)
self.size_selected_previous = self.size_selected
print(self.Dx, self.Dy, self.Cx, self.Cy)
def on_touch_down(self, touch):
with self.canvas:
Color(self.line_color)
# Save initial tap position
self.Ax, self.Ay = self.first_touch_x, self.first_touch_y = touch.x, touch.y
# Initilize positions to save
self.Bx, self.By = 0, 0
self.Cx, self.Cy = 0, 0
self.Dx, self.Dy = 0, 0
# Create initial point with touch x and y postions.
self.line = Line(points=([self.Ax, self.Ay]), width=self.line_width, joint='miter', joint_precision=30)
# Save the created line
self.list_lines_in_image.append(self.line)
print("on_touch_down")
def remove_old_line(self, instance=None, list_lines=None):
if len(self.list_lines_in_image) > 1:
self.delete_line()
def delete_line(self, pos=0):
try:
self.list_lines_in_image.pop(pos).points = []
except:
pass
def on_touch_move(self, touch):
# Assign the position of the touch at the point C
self.Cx, self.Cy = touch.x, touch.y
# There are two known points A (starting point) and C (endpoint)
# Assign the positions x and y known of the points
self.Bx, self.By = self.Cx, self.Ay
self.Dx, self.Dy = self.Ax, self.Cy
# Assign points positions to the last line created
self.line.points = [self.Ax, self.Ay,
self.Bx, self.By,
self.Cx, self.Cy,
self.Dx, self.Dy,
self.Ax, self.Ay]
self.size_selected_temp = abs(self.Cx - self.Dx), abs(self.Cy - self.By)
def tap_not_draw_a_line(self):
return (self.size_selected[0] == 0 and self.size_selected[1] == 0)
class BaseBubbleButtons(Bubble):
def __init__(self, **kwargs):
super(BaseBubbleButtons, self).__init__(**kwargs)
def hide(self, instance=None, value=None):
self.opacity = 0
def show(self, instance=None, value=None):
self.opacity = 1
class BubbleButtons(BaseBubbleButtons):
resize_button = ObjectProperty()
cut_button = ObjectProperty()
rotate_button = ObjectProperty()
class BubbleButtonsUndoConfirm(BaseBubbleButtons):
undo_button = ObjectProperty()
confirm_button = ObjectProperty()
class App_R3App(App):
Builder.load_file('App_R3.kv')
def build(self):
return sm
def on_start(self):
return True
def on_pause(self):
return True
def on_resume(self):
return True
def on_stop(self):
return True
if __name__ == '__main__':
# Create the screen manager
sm = ScreenManager()
sm.add_widget(FirstScreen(name='_first_screen_'))
sm.add_widget(SecondScreen(name='_second_screen_'))
sm.add_widget(ThirdScreen(name='_third_screen_'))
sm.add_widget(EditImageScreen(name='_edit_image_screen_'))
App_R3App().run()
App_R3.kv
#:import Window kivy.core.window.Window
<MyScreenManager>:
FirstScreen:
id: first_screen
SecondScreen:
id: second_screen
ThirdScreen:
id: third_screen
EditImageScreen:
id: edit_image_screen
<FirstScreen>:
name: '_first_screen_'
BoxLayout:
orientation: "horizontal"
Label:
id: first_screen_label
text: "Hi, I'm the home page"
BoxLayout:
orientation: "vertical"
Button:
text: "Okay!"
on_press: root.manager.current = '_second_screen_'
Button:
text: "Cancel!"
on_press: app.stop()
<SecondScreen>:
name: '_second_screen_'
id: file_chooser
BoxLayout:
id: file_chooser_box_layout
orientation: "horizontal"
Button
text: "Open"
on_press: root.hl(file_chooser_list_view.selection)
FileChooserListView:
id: file_chooser_list_view
<ThirdScreen>:
name: '_third_screen_'
id: third_screen
xx1: root.x1
yy1: root.y1
tt_x: root.t_x
tt_y: root.t_y
BoxLayout:
orientation: "vertical"
id: third_screen_boxlayout
Label:
id: main_title
text: root.title
size_hint: (1, 0.1)
BoxLayout:
id: image_box_layout
# limits the box layout to the position of the image
Image:
id: main_image
source: root.image_address
pos_hint: {'center_x': 0.5, 'center_y': 0.5}
BoxLayout:
id: button_boxlayout
orientation: "horizontal"
padding: 10
size_hint: (1, 0.15)
Button:
id: accept_button
text: "Okay"
size_hint: (0.33, 1)
on_press: root.image_accepted_by_user(root.image_address)
Button:
id: crop_button
text: "Crop"
size_hint: (0.33, 1)
on_press: root.enable_cropping()
Button:
id: cancel_button
text: "Cancel"
size_hint: (0.33, 1)
on_press: root.manager.current = '_first_screen_'
<EditImageLayout>:
rectangle_selector: rectangle_selector
text_size_rectangle: text_size_rectangle
image_layout: image_layout
bubble_buttons: bubble_buttons
bubble_buttons_undo_confirm: bubble_buttons_undo_confirm
canvas.before:
Color:
rgba: (1, 1, 1, 0.2)
Rectangle:
pos: self.pos
size: Window.width, Window.height
Label:
id: text_size_rectangle
pos_hint_x: None
pos_hint_y: None
pos: Window.width*.45, Window.height*.45
color: (1, 1, 1, 1)
ImageLayout:
id: image_layout
size: Window.width*.8, Window.height*.8
pos: Window.width*.1, Window.height*.1
size_hint: None, None
pos_hint_x: None
pos_hint_y: None
TouchSelector:
id: rectangle_selector
BubbleButtons:
id: bubble_buttons
size_hint: (None, None)
size: (200, 40)
pos_hint_x: None
pos_hint_y: None
pos: Window.width*.4, Window.height*.1
opacity: 0
arrow_pos: 'top_mid'
BubbleButtonsUndoConfirm:
id: bubble_buttons_undo_confirm
size_hint: (None, None)
size: (200, 40)
pos_hint_x: None
pos_hint_y: None
pos: Window.width*.4, Window.height*.9
opacity: 0
arrow_pos: 'top_mid'
<BubbleButtons>:
resize_button: resize_button
cut_button: cut_button
rotate_button: rotate_button
BubbleButton:
id: resize_button
text: 'Resize'
BubbleButton:
id: cut_button
text: 'Cut'
BubbleButton:
id: rotate_button
text: 'Rotate'
<BubbleButtonsUndoConfirm>:
undo_button: undo_button
confirm_button: confirm_button
BubbleButton:
id: undo_button
text: 'Undo'
BubbleButton:
id: confirm_button
text: 'Confirm'
Console output, aka what the code prints (you can see that ImageLayout and CoreImage run twice)
EditImageScreen
enable_cropping
on_pre_enter
EditImageLayout
ImageLayout
CoreImage
ImageLayout
CoreImage
What I suspect is happening is that the super() is calling the base class EditImageLayout, the static elements of that base class are calling the .kv file and initating the ImageLayout and CoreImage classes from there. At the same time, "self" goes into action and does the exact same thing. This causes trouble later on when I implement on_touch_down over it (on_touch_down then appears twice, etc. )
Problem
ImageLayout and CoreImage were called twice.
[INFO ] [GL ] Unpack subimage support is available
enable_cropping
on_pre_enter
EditImageLayout
ImageLayout
CoreImage
ImageLayout
CoreImage
[INFO ] [Base ] Leaving application in progress...
Process finished with exit code 0
Root Cause
The double calls to ImageLayout and CoreImage were due to two kv files, App_R3.kv and app_r3.kv present as shown in the screen shots below. In the application, the app class is App_R3App(App): and it is using Builder.load_file('App_R3.kv') to load kv code into application.
Solution
Remove kv file, app_r3.kv. In the example, we renamed it to app_r3-off.kv
Kv language » How to load KV
There are two ways to load Kv code into your application:
By name convention:
Kivy looks for a Kv file with the same name as your App class in
lowercase, minus “App” if it ends with ‘App’ e.g:
MyApp -> my.kv
If this file defines a Root Widget it will be attached to the App’s
root attribute and used as the base of the application widget tree.
By Builder:
You can tell Kivy to directly load a string or a file. If this string
or file defines a root widget, it will be returned by the method:
Builder.load_file('path/to/file.kv')
or:
Builder.load_string(kv_string)
Recommendations
Since class rule, <MyScreenManager>: is defined in your kv file, you should use it rather than define sm = ScreenManager() in your Python code. On top of that, keep the view/design separate.
kv file
Add missing class rule for EditImageScreen.
<EditImageScreen>:
name: '_edit_image_screen_'
<EditImageLayout>:
Python code
Add class definition for MyScreenManager
In build() method, replace return sm with return MyScreenManager()
Before App_R3().run(), remove all references to sm
Since each screen has by default a property manager that gives you the instance of the ScreenManager used. In callback_image() and enable_cropping() methods, replace sm.current with self.manager.current
In __init__() method of EditImageLayout() class, remove self.sm = kwargs.pop('sm', None). If you need to access the root/ScreenManager, use sm = App.get_running_app().root
Snippet
class MyScreenManager(ScreenManager):
pass
...
def callback_image(self, new_image_address, image_address, title):
self.manager.current = "_third_screen_"
self.new_image_address = new_image_address
...
def enable_cropping(self):
...
print("enable_cropping")
self.manager.current = "_edit_image_screen_"
...
def __init__(self, **kwargs):
print("EditImageLayout")
self.crop_image_screen = kwargs.pop('crop_image_screen', None)
...
class App_R3App(App):
def build(self):
return MyScreenManager()
if __name__ == '__main__':
App_R3App().run()
ScreenManager » Basic Usage
Each screen has by default a property manager that gives you the
instance of the ScreenManager used.
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"
"""