class CircleApp(App):
def connect(self):
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.connect((host, port))
self.previous_data = 0
def build(self):
layout1 = BoxLayout(orientation='horizontal')
self.e1 = Slider(min=0, max=100, value=0, orientation='vertical')
self.txt = Label()
self.txt.text = 'Volume : ' + '0'
layout1.add_widget(self.e1)
layout1.add_widget(self.txt)
self.e1.bind(value=self.updateValue)
return layout1
def updateValue(self, nstance, value):
if int(value) != self.previous_data:
self.previous_data = int(value)
self.txt.text = 'Volume : ' + str(int(value))
try:
self.s.send(str(int(value % 100.1)))
except:
pass
def recieveData(self):
while True:
try:
data = self.s.recv(1024)
self.txt.text = 'Volume : ' + str(int(data))
self.e1.value = int(data)
except:
pass
def on_pre_enter(self):
# Set up the slider
slider = Slider(min=int(cur_setting['min']),
max=int(cur_setting['max']),
value=main.App.get_running_app().config.getint('Camera', cur_setting['key']),
orientation='vertical',
size_hint=(0.2, 0.75),
pos_hint={'x':0.8, 'y':0.17},
step=1)
# Add a label up the top showing the slider value
self.label = Label(text='{0}: {1}'.format(cur_setting['title'], int(slider.value)),
size_hint=(0.2, 0.1),
pos_hint={'x':0.8, 'y':0.9})
# Add the close button to the bottom
back_button = Button(text='Back',
size_hint=(0.2, 0.16),
pos_hint={'x':0.8, 'y':0})
# Bind the events
slider.bind(value=self.change_setting)
back_button.bind(on_release=self.back_button_press)
# Add to floatlayout.
floaty = FloatLayout()
floaty.add_widget(slider)
floaty.add_widget(self.label)
floaty.add_widget(back_button)
self.add_widget(floaty)
class WidgetContainer(GridLayout):
def __init__(self, **kwargs):
super(WidgetContainer, self).__init__(**kwargs)
# 2 columns in grid layout
self.cols = 2
self.brightnessControl = Slider(min=0, max=100)
# 1st row - one label, one slider
self.add_widget(Label(text='brightness'))
self.add_widget(self.brightnessControl)
# 2nd row - one label for caption, one label for slider value
self.add_widget(Label(text='Slider Value'))
self.brightnessValue = Label(text='0')
self.add_widget(self.brightnessValue)
# On the slider object Attach a callback for the attribute named value
self.brightnessControl.bind(value=self.on_value)
def on_value(self, instance, brightness):
self.brightnessValue.text = "%d" % brightness
def build(self):
from kivy.uix.slider import Slider
def test(*ars):
gauge.value = s.value
print(s.value)
def test_(*ars):
gauge_.value = s1.value
print(s.value)
box = BoxLayout(orientation='vertical', spacing=10, padding=10)
gauge = Gauge(value=50, size_gauge=256, size_text=9)
gauge_ = Gauge(value=50, size_gauge=256, size_text=19)
box.add_widget(gauge)
box.add_widget(gauge_)
s = Slider(min=0, max=100, value=50)
s.bind(value=test)
box.add_widget(s)
s1 = Slider(min=0, max=100, value=50)
s1.bind(value=test_)
box.add_widget(s1)
return box
class WidgetContainer(GridLayout):
def __init__(self, **kwargs):
# super function can be used to gain access
# to inherited methods from a parent or sibling
# class that has been overwritten in a class object.
super(WidgetContainer, self).__init__(**kwargs)
# 4 columns in grid layout
self.cols = 4
# declaring the slider and adding some effects to it
self.brightnessControl = Slider(min=0, max=100)
# 1st row - one label, one slider
self.add_widget(Label(text='Brightness'))
self.add_widget(self.brightnessControl)
# 2nd row - one label for caption,
# one label for slider value
self.add_widget(Label(text='Slider Value'))
self.brightnessValue = Label(text='0')
self.add_widget(self.brightnessValue)
# On the slider object Attach a callback
# for the attribute named value
self.brightnessControl.bind(value=self.on_value)
# Adding functionality behind the slider
# i.e when pressed increase the value
def on_value(self, instance, brightness):
self.brightnessValue.text = "% d" % brightness
def setup_gui(self):
self.ParentLayout = GridLayout(cols=3, row_force_default=True, row_default_height=200)
self.label = Label(text='connecting...\n')
# Additional code to exercise, so you can adapt related code on server for example
Matrix_Row_Slider = Slider(min=0, max=8, value=1)
Matrix_Row_Slider.bind(value=self.onMatrix_Row_Slidervalue) # handy to know what are the slider's position
Matrix_Col_Slider = Slider(min=0, max=8, value=1)
Matrix_Col_Slider = Slider(orientation='vertical')
self.ParentLayout.add_widget(Matrix_Row_Slider)
self.Matrix_Layout = GridLayout(cols=8)
# Let's add a spinner to be able to select some colors
self.Colorspinner = Spinner(text='Green', values=('NA','Green','Red','Orange', 'Cls'), size_hint=(None, None),size=(90, 44), pos_hint={'center_x': .5, 'center_y': .5})
# We define the main buttons matrix here
for i in range(64):
btn = Button(text=str(i), size_hint_x=None,size_hint_y=None, width=20, height=20 )
btn.bind(on_press=self.callback)
self.Matrix_Layout.add_widget(btn)
self.ParentLayout.add_widget(self.Matrix_Layout)
self.ParentLayout.add_widget(self.label)
self.ParentLayout.add_widget(self.Colorspinner)
self.ParentLayout.add_widget(Matrix_Col_Slider)
return self.ParentLayout
def build(self): #UIの構築等
args = sys.argv
self.src = cv2.imread(args[1], cv2.IMREAD_GRAYSCALE)
if self.src is None:
return -1
self.src = cv2.flip(self.src, 0)
# ButtonやSlider等は基本size_hintでサイズ比率を指定(絶対値の時はNoneでsize=)
# Imageに後で画像を描く
self.kvImage1 = Image(size_hint=(1.0, 0.7))
# Layoutを作ってadd_widgetで順次モノを置いていく(並びは置いた順)
kvBoxLayout1 = BoxLayout(orientation='vertical')
kvBoxLayout1.add_widget(self.kvImage1)
# ここだけ2columnでkvBoxLayout2にLabelとSliderを並べてkvBoxLayout1に渡す
# Verticalの中に置くhorizontalなBoxLayout (ここだけ2column)
kvBoxLayout2 = BoxLayout(orientation='horizontal',
size_hint=(1.0, 0.1))
self.kvSliderLabel = Label(text='Threshold',
size_hint=(0.3, 1.0),
halign='center')
kvSlider = Slider(size_hint=(0.7, 1.0), min=0, max=255, value=128)
kvSlider.bind(value=self.sliderCallback)
kvBoxLayout2.add_widget(self.kvSliderLabel)
kvBoxLayout2.add_widget(kvSlider)
kvBoxLayout1.add_widget(kvBoxLayout2)
self.process(kvSlider.value)
return kvBoxLayout1
def build(self):
from kivy.animation import Animation
from kivy.uix.slider import Slider
from random import random
def update(*args):
Animation(value=slider.value, duration=speed,
t=easing).start(gauge)
easing = 'in_out_quad'
speed = 1
vmin = 0
vmax = 100
value = round(random() * vmax)
gauge = Gauge(header='km/h',
line_width=20,
max=vmax,
min=vmin,
mode=0,
value=value)
slider = Slider(min=vmin, max=vmax, value=vmin)
slider.value = value
slider.bind(value=update)
layout = BoxLayout()
layout.add_widget(gauge)
layout.add_widget(slider)
return layout
def on_enter(self):
popup = Popup(title='Dish Options', size_hint=(1,1))
layout1 = StackLayout(orientation='lr-bt') #This time the options are layed out in a stack layout, so that I can have multiple options in a small space
closebutton = Button(text='I want to make a different dish', size_hint=(0.9,0.05)) #This is a button that will make a different dish for the user
closebutton.bind(on_press= popup.dismiss) #The size_hint is the x and y co-ordinate score of how much percentage of the screen the button will have (with 1 being all the screen)
closebutton.bind(on_release = self.change_page)
scrlv = ScrollView(size_hint=(0.9,0.95)) #This adds a scrollable bar to the list of dishes, if there are lots of them
slid = Slider(min=0, max=1, value=25, orientation='vertical', step=0.01, size_hint=(0.1, 0.95)) #The slid is the physical slider used, which calles the scrlv
#step is the percentage of the screen it takes up, min and max are always 1 and 0 as they show the ful percentage of the screen covered by the bar
scrlv.bind(scroll_y=partial(self.slider_change, slid))
#what this does is, whenever the slider is dragged, it scrolls the previously added scrollview by the same amount the slider is dragged
slid.bind(value=partial(self.scroll_change, scrlv))
layout2 = GridLayout(cols=4, size_hint_y=None) #This is another grdi layout used within the popup
layout2.bind(minimum_height=layout2.setter('height')) #Bind the height of the layout to the minimum height so that the scroll bar functions
for txt in choices:
btn = Button(text=txt, size_hint_y=None, height=80, valign='middle', font_size=12) # Add a button for each dish
btn.text_size = (btn.size) #set the buttons so that their size changes depending on the screen size
btn.bind(on_press = self.find_dish) #When the button is pressed, call the find_dish subroutine
btn.bind(on_release = popup.dismiss) #Close the popup if they click the button
layout2.add_widget(btn) # Add the buttons to the layout
scrlv.add_widget(layout2)
layout1.add_widget(closebutton) #Add the close button to the layout
layout1.add_widget(scrlv) # Add the scroll bar to the layout
layout1.add_widget(slid) #Add the slider to the layout for the scroll bar
popup.content = layout1
popup.open()
if len(choices) == 0:
popup.dismiss()
sm.current = "main" #This changes the screen back to the original "main" screen if there are no dishes, which allows the users to choose another dish
def __init__(self, points=[], loop=False, *args, **kwargs):
super(BezierTest, self).__init__(*args, **kwargs)
self.d = 10
self.points = points
self.loop = loop
self.current_point = None
with self.canvas:
Color(1.0, 0.0, 0.0)
self.bezier = Bezier(
points=self.points,
segments=150,
loop=self.loop,
dash_length=100,
dash_offset=10)
Color(1.0, 0.0, 1.0)
self.line = Line(
points=self.points+self.points[:2],
dash_offset=10,
dash_length=100)
s = Slider(y=0, pos_hint={'x': .3}, size_hint=(.7, None), height=50)
s.bind(value=self._set_bezier_dash_offset)
self.add_widget(s)
s = Slider(y=50, pos_hint={'x': .3}, size_hint=(.7, None), height=50)
s.bind(value=self._set_line_dash_offset)
self.add_widget(s)
class WidgetContainer(GridLayout):
"""Gere affichage et refresh auto du layout principal"""
def __init__(self, **kwargs):
super(WidgetContainer, self).__init__(**kwargs)
self.cols = 1
self.my_array = MyArray()
self.mySlider = Slider(min=30, max=60, value=30)
self.mySlider.bind(value=self.on_frequency)
self.mySliderValue = Label(text='30 Hz')
self.myButton = Button(text="Quit")
self.myButton.bind(on_press=self.click_exit)
self.add_widget(self.my_array)
self.add_widget(self.mySlider)
self.add_widget(self.mySliderValue)
self.add_widget(self.myButton)
self.auto_refresh = Clock.schedule_interval(self.refresh_array, 1 / 30)
def refresh_array(self, _):
# le layout est redessine automatiquement
self.my_array.refresh()
def on_frequency(self, _, value):
self.mySliderValue.text = "%d Hz" % value
period = 1 / value
self.auto_refresh.cancel() # Precedent schedule annule
self.auto_refresh = Clock.schedule_interval(self.refresh_array, period)
@staticmethod
def click_exit(_):
exit(0)
class SliderulMeu(GridLayout):
def __init__(self, **kwargs):
super(SliderulMeu, self).__init__(**kwargs)
self.cols = 1
self.padding = 150
self.toggle1 = ToggleButton(text="muzica")
self.toggle1.background_normal = "on.png"
self.toggle1.background_down = "off.png"
self.add_widget(self.toggle1)
self.arata_volum = Label (text = "volum: 10")
self.add_widget(self.arata_volum)
self.slide_muzica = Slider(min=0, max=100, value=10)
self.slide_muzica.step = 5
self.slide_muzica.orientation="horizontal" # alte optiuni 'vertical'
self.add_widget(self.slide_muzica)
self.toggle1.bind(on_press=self.dezactiveaza_volum)
self.slide_muzica.bind(value=self.valoare_volum)
def valoare_volum (self,x,y):
'''utilziat pentru a vedea volumul'''
self.arata_volum.text = "volum: "+str(int(self.slide_muzica.value))
def dezactiveaza_volum (self,x):
'''utilziat pentru a acctiva sau a dezactiva slider-ul'''
if (self.toggle1.state == "down") :
self.slide_muzica.disabled =True
else:
self.slide_muzica.disabled =False
self.slide_muzica.value = 0
class OptionsApp(App):
def __init__(self, appState):
super(OptionsApp, self).__init__()
self.appState = appState
def build(self):
layout = BoxLayout(orientation='vertical')
row1 = BoxLayout(orientation='horizontal')
self.slider = Slider(min=0, max=500, step=1, size=(800, 50))
self.slider.bind(value=self.OnSliderValueChange)
self.label = Label(text=str(self.appState['xPos']))
row1.add_widget(self.slider)
row1.add_widget(self.label)
row2 = BoxLayout(orientation='horizontal')
self.slider2 = Slider(min=0, max=500, step=1, size=(800, 50))
self.slider2.bind(value=self.OnSliderValueChange2)
self.label2 = Label(text=str(self.appState['yPos']))
row2.add_widget(self.slider2)
row2.add_widget(self.label2)
layout.add_widget(row1)
layout.add_widget(row2)
return layout
def OnSliderValueChange(self, instance, value):
self.appState['xPos'] = value
self.label.text = str(value)
def OnSliderValueChange2(self, instance, value):
self.appState['yPos'] = value
self.label2.text = str(value)
def __init__(self, points=[], loop=False, *args, **kwargs):
super(BezierTest, self).__init__(*args, **kwargs)
self.d = 10 # pixel tolerance when clicking on a point
self.points = points
self.loop = loop
self.current_point = None # index of point being dragged
with self.canvas:
Color(1.0, 0.0, 0.0)
self.bezier = Bezier(points=self.points,
segments=150,
loop=self.loop,
dash_length=100,
dash_offset=10)
Color(1.0, 0.0, 1.0)
self.line = Line(points=self.points + self.points[:2],
dash_offset=10,
dash_length=100)
s = Slider(y=0, pos_hint={'x': .3}, size_hint=(.7, None), height=50)
s.bind(value=self._set_bezier_dash_offset)
self.add_widget(s)
s = Slider(y=50, pos_hint={'x': .3}, size_hint=(.7, None), height=50)
s.bind(value=self._set_line_dash_offset)
self.add_widget(s)
class SliderButton(PopupButton):
def __init__(self,**kwargs):
self.min=kwargs.pop('min',0)
self.max=kwargs.pop('max',100)
self.step=kwargs.pop('step',1)
#self.on_update=kwargs.pop('on_update',None)
self.sliderBind=False
super(SliderButton,self).__init__(**kwargs)
self.slider=Slider(min=self.min,value=self.value,max=self.max,step=self.step,cursor_width='32sp',orientation=self.popup_orientation,size_hint=(1,1),size=('25sp','100sp'))
self.popupBox.add_widget(self.slider)
#self.popupBox.title=str(self.value)
def bindTouchUp(self,*args):
self.slider.bind(on_touch_up=self.updateValue)
def updateValue(self,instance,event):
self.value=int(self.slider.value)
self.slider.unbind(on_touch_up=self.updateValue)
self.slider.unbind(on_touch_move=self.updatePopup)
#self.popup.title=str(self.text_top) + str(': ') + str(self.slider.value)
super(SliderButton,self).updateValue(self.value)
def updatePopup(self,*args):
self.popup.title=str(self.text_top) + str(' : ') + str(self.slider.value)
Clock.schedule_once(self.bindTouchUp,0.5)
def pressEvent(self,*args):
self.slider.value=self.value
super(SliderButton,self).pressEvent(self,*args)
self.slider.bind(on_touch_move=self.updatePopup)
self.updatePopup()
def __init__(self, min=0, max=10, value=5, on_change=None, **kwargs):
super().__init__(**kwargs)
w = Slider(min=min, max=max, value=value, step=0.1)
if callable(on_change): w.bind(value=on_change)
self.field = w
self.ids['layout'].add_widget(w)
def build(self): #UIの構築等
self._cap = cv2.VideoCapture(0)
# ButtonやSlider等は基本size_hintでサイズ比率を指定(絶対値の時はNoneでsize=)
# 日本語フォントを使いたいときはfont_nameでフォントへのパス
kvButton1 = Button(text='ボタン', size_hint=(1.0, 0.1), font_name='/usr/local/texlive/texmf-local/fonts/truetype/cjk-gs-integrate/ipag.ttf')
kvButton1.bind(on_press = self.buttonCallback) #bindでイベントごとにコールバック指定
# Imageに後で画像を描く
self.kvImage1 = Image(size_hint=(1.0, 0.7))
# Layoutを作ってadd_widgetで順次モノを置いていく(並びは置いた順)
kvLayout1 = BoxLayout(orientation='vertical')
kvLayout1.add_widget(self.kvImage1)
# ここだけ2columnでLabelとSliderを並べる
# Verticalの中に置くhorizontalなBoxLayout
kvLayout2 = BoxLayout(orientation='horizontal', size_hint=(1.0, 0.1))
self.kvSlider1Label = Label(text = 'Slider', size_hint=(0.3, 1.0), halign='center')
kvSlider1 = Slider(size_hint=(0.7, 1.0))
kvSlider1.bind(value=self.slideCallback)
kvLayout1.add_widget(kvLayout2)
kvLayout2.add_widget(self.kvSlider1Label)
kvLayout2.add_widget(kvSlider1)
# 1columnに戻る
kvLayout1.add_widget(kvButton1)
#カメラ待ち
while not self._cap.isOpened():
pass
# 更新スケジュールとコールバックの指定
Clock.schedule_interval(self.update, 1.0/30.0)
return kvLayout1
def on_enter(self):
layout = self.ids.otherlayout
floatEr = FloatLayout(size=(480,800))
player = Music_Player()
self.label = Label(text=str(self.slider_val))
s = Slider(min=0, max=player.current_playing.length, value_track=True, value_track_color=[1, 0, 0, 1], sensitivity='handle', pos = (0, 300), size = (100, 30))
s.step = .01
btnp = Button(text='play', size=(96,72), pos = (0,72))
btnpau = Button(text='pause', size=(96,72), pos = (96,72))
btnb = Button(text='back', size=(96,72), pos = (192,72))
btn2 = Button(text='go to list', size=(96,72), pos = (288,72))
btnn = Button(text='next', size=(96,72), pos = (384,72))
pb = ProgressBar(max=player.current_playing.length)
pb.bind(value=lambda
x:self.sliderProgress(player.current_playing.get_pos()))
btn2.bind(on_press=self.changer)
btnp.bind(on_press=lambda x:player.play())
btnpau.bind(on_press=lambda x:player.pause())
btnb.bind(on_press=lambda x:player.back())
btnn.bind(on_press=lambda x:player.next())
s.bind(value=self.sliderProgress)
s.bind(on_touch_up=lambda x, y:player.playAtTime(self.sliderProgress))
floatEr.add_widget(btn2)
floatEr.add_widget(btnp)
floatEr.add_widget(btnpau)
floatEr.add_widget(btnn)
floatEr.add_widget(btnb)
floatEr.add_widget(s)
floatEr.add_widget(pb)
layout.add_widget(self.label)
layout.add_widget(floatEr)
def build(self):
from kivy.uix.slider import Slider
def test(*ars):
gauge.value = s.value
print(s.value)
def test_(*ars):
gauge_.value = s1.value
print(s.value)
box = BoxLayout(orientation='vertical', spacing=10, padding=10)
gauge = Gauge(value=50, size_gauge=256, size_text=9)
gauge_ = Gauge(value=50, size_gauge=256, size_text=19)
box.add_widget(gauge)
box.add_widget(gauge_)
s = Slider(min=0, max=100, value=50)
s.bind(value=test)
box.add_widget(s)
s1 = Slider(min=0, max=100, value=50)
s1.bind(value=test_)
box.add_widget(s1)
return box
class time_layout(BoxLayout):
def __init__(self,strin,no,colors):
super().__init__()
self.orientation="vertical"
"""self.scrlv=ScrollView(size_hint=(0.8,0.8))
temp=GridLayout(cols=1, size_hint_y=None)
temp.bind(minimum_height=temp.setter('height'))"""
self.s=Slider(value=0,min=0,max=no-1,step=1)
"""
for i in range(0, no):
btn = Label(text=str(i), size_hint_y=None, size_hint_x=0.2,height=10, valign='middle',halign='center', font_size=5)
btn.text_size = (btn.size)
temp.add_widget(btn)
self.scrlv.add_widget(temp)"""
label=Label(text=strin,color=colors)
#self.label1=Label(text=str(int((1-self.scrlv.scroll_y)*no)))
self.label1=Label(text=str(int(self.s.value)),color=colors)
"""def corelate(instance,value):
self.label1.text=str(int((1-self.scrlv.scroll_y)*no))"""
def corelate(instance,value):
self.label1.text=str(int(self.s.value))
#self.scrlv.bind(scroll_y=corelate)
self.s.bind(value=corelate)
self.add_widget(label)
self.add_widget(self.label1)
self.add_widget(self.s)
class Switch_implementare(GridLayout):
def __init__(self, **kwargs):
super(Switch_implementare, self).__init__(**kwargs)
self.cols = 1
self.padding = 150
self.switch1 = Switch()
self.switch1.active = True
self.add_widget(self.switch1)
self.arata_volum = Label(text="volum: 10")
self.add_widget(self.arata_volum)
self.slide_muzica = Slider(min=0, max=100, value=10)
self.slide_muzica.step = 5
self.slide_muzica.orientation = "horizontal" # alte optiuni 'vertical'
self.add_widget(self.slide_muzica)
self.switch1.bind(active=self.dezactiveaza_volum)
self.slide_muzica.bind(value=self.valoare_volum)
def valoare_volum(self, x, y):
'''utilziat pentru a vedea volumul'''
self.arata_volum.text = "volum: " + str(int(self.slide_muzica.value))
def dezactiveaza_volum(self, x, y):
'''utilziat pentru a acctiva sau a dezactiva slider-ul'''
if (self.switch1.active == False):
self.slide_muzica.disabled = True
else:
self.slide_muzica.disabled = False
self.slide_muzica.value = 0
def build(self):
main_layout = BoxLayout(orientation='horizontal')
oil_layout = BoxLayout(orientation='vertical')
water_layout = BoxLayout(orientation='vertical')
oil_label = Label(text='Öl', size_hint = (1, None), font_size = 30)
oil_temp_label = Label(text='20 °C', size_hint = (1, None), font_size = 30)
self.oil_temp_label = oil_temp_label
oil_slider = Slider(min = 0, max = 150, value = 20, orientation = 'vertical')
self.oil_slider = oil_slider
oil_slider.bind(value=self.on_oil_slider)
oil_layout.add_widget(oil_label)
oil_layout.add_widget(oil_slider)
oil_layout.add_widget(oil_temp_label)
water_label = Label(text='Wasser', size_hint = (1, None), font_size = 30)
water_temp_label = Label(text='10 °C', size_hint = (1, None), font_size = 30)
self.water_temp_label = water_temp_label
water_slider = Slider(min = 0, max = 40, value = 10, orientation = 'vertical')
self.water_slider = water_slider
water_slider.bind(value=self.on_water_slider)
water_layout.add_widget(water_label)
water_layout.add_widget(water_slider)
water_layout.add_widget(water_temp_label)
main_layout.add_widget(oil_layout)
main_layout.add_widget(water_layout)
return main_layout
class SetInternalVariableWidget(GridLayout):
def __init__(self, img_file, **kwargs):
super(SetInternalVariableWidget, self).__init__(**kwargs)
self.rows = 1
self.img = Image(source=img_file)
# Improve rendering via OpenGl
self.img.mipmap = True
self.img.size_hint_x = None
self.img.width = 30
self.slider = Slider(min=0,
max=1,
value=0.25,
size_hint_x=None,
width=235)
self.label = Label(text=str(self.slider.value),
font_size='17sp',
size_hint_x=None,
width=50)
self.slider.bind(value=self.on_slider_value_change)
self.add_widget(self.img)
self.add_widget(self.slider)
self.add_widget(self.label)
def on_slider_value_change(self, obj, val):
self.label.text = str("{0:.2f}".format(val))
def value(self):
return self.slider.value
def build(self):
from kivy.uix.slider import Slider
def test(*ars):
#gauge.value = s.value
gauge.set_animate(s.value)
print(s.value)
def test_(*ars):
gauge_.value = s1.value
print(s.value)
box = BoxLayout(orientation='vertical', spacing=10, padding=10)
gauge = Gauge(50, 0, 200, size_text=9)
gauge_ = Gauge(value=50,
size_text=19,
half_widget=True,
show_progress=False)
box.add_widget(gauge)
box.add_widget(gauge_)
s = Slider(min=0, max=200, value=50)
s.bind(value=test)
box.add_widget(s)
s1 = Slider(min=0, max=100, value=50)
s1.bind(value=test_)
box.add_widget(s1)
return box
def build(self):
root = BoxLayout(orientation='vertical')
viewer = KinectViewer()
root.add_widget(viewer)
toolbar = BoxLayout(size_hint=(1, None), height=50)
root.add_widget(toolbar)
slider = Slider(min=1., max=10., value=1.)
def update_depth_range(instance, value):
viewer.depth_range = value
slider.bind(value=update_depth_range)
toolbar.add_widget(slider)
button = Button(text='Use RGB shader')
def use_rgb(*l):
viewer.canvas.shader.fs = rgb_kinect
button.bind(on_press=use_rgb)
toolbar.add_widget(button)
button = Button(text='Use HSV shader')
def use_hsv(*l):
viewer.canvas.shader.fs = hsv_kinect
button.bind(on_press=use_hsv)
toolbar.add_widget(button)
return root
def __init__(self, childHeight, **kwargs):
super(ListView,self).__init__(**kwargs)
self.__childHeight = childHeight
scroll = ScrollViewFixed(bar_width=30,
bar_margin=-30,
bar_color=[0.8,.8,.8,.99],
do_scroll_y = True,
do_scroll_x = False,
pos_hint= {'x':0,'y':0},
size_hint = (None,None),
size = self.size)
box = BoxLayout(orientation='vertical',size_hint=(None,None),
size = self.size)
scroll.add_widget(box)
super(ListView, self).add_widget(scroll)
s = Slider(orientation='vertical', value_normalized = 0.5,
size_hint =(None,None), padding = 20,
size = (30, self.size[1]), pos_hint = {'x':1, 'y':0})
scroll.slider = s
def scrollMoves(slid,pos):
scroll.scroll_y = pos
s.bind(value_normalized=scrollMoves)
super(ListView, self).add_widget(s, 1)
self.scroll = scroll
self.box = box
class DraggableScrollbar(GridLayout): slider = None def __init__(self, recycleView, **kwargs): # call the constructor of parent # if they are any graphics object, they will be added on our new canvas super(DraggableScrollbar, self).__init__(**kwargs) self.cols = 2 self.orientation='lr-bt' #the last child of layout1 and this will act as the draggable scrollbar self.slider = Slider(min=0, max=1, value=25, orientation='vertical', step=0.01, size_hint=(0.1, 0.95)) recycleView.bind(scroll_y=partial(self.slider_change)) #what this does is, whenever the slider is dragged, it scrolls the previously added scrollview by the same amount the slider is dragged self.slider.bind(value=partial(self.scroll_change, recycleView)) self.add_widget(recycleView) self.add_widget(self.slider) def scroll_change(self, recycleView, instance, value): recycleView.scroll_y = value def slider_change(self, instance, value): if value >= 0: #this to avoid 'maximum recursion depth exceeded' error self.slider.value=value
class Tela(GridLayout):
def __init__(self, **kwargs):
super(Tela, self).__init__(**kwargs)
self.cols = 1
# slider vertical
self.sl = Slider(orientation='vertical', min=0, max=100, value=50)
self.add_widget(self.sl)
# barra de progresso
self.pb = ProgressBar(max=100)
self.pb.value = 50
self.add_widget(self.pb)
# exibir texto simples
self.add_widget(Label(text='Valor Atual :'))
# valor do slider
self.valor = Label(text='0')
self.add_widget(self.valor)
# vinculando evento ao slider
self.sl.bind(value=self.on_value)
def on_value(self, instance, valor):
self.valor.text = "%d" % valor
self.pb.value = valor
def build(self): # Set up the layout: layout = GridLayout(cols=5, spacing=30, padding=30, row_default_height=150) # Make the background gray: with layout.canvas.before: Color(.2,.2,.2,1) self.rect = Rectangle(size=(800,600), pos=layout.pos) # Instantiate the first UI object (the GPIO input indicator): inputDisplay = InputButton(text="Input") # Schedule the update of the state of the GPIO input button: Clock.schedule_interval(inputDisplay.update, 1.0/10.0) # Create the rest of the UI objects (and bind them to callbacks, if necessary): outputControl = ToggleButton(text="LED") outputControl.bind(on_press=press_callback) beepButton = Button(text="BEEP!") beepButton.bind(on_press=press_callback) wimg = Image(source='logo.png') speedSlider = Slider(orientation='vertical', min=1, max=30, value=speed) speedSlider.bind(on_touch_down=update_speed, on_touch_move=update_speed) # Add the UI elements to the layout: layout.add_widget(wimg) layout.add_widget(inputDisplay) layout.add_widget(outputControl) layout.add_widget(beepButton) layout.add_widget(speedSlider) # Start flashing the LED Clock.schedule_once(flash, 1.0/speed) return layout
def build(self):
root = BoxLayout(orientation='vertical')
viewer = KinectViewer()
root.add_widget(viewer)
toolbar = BoxLayout(size_hint=(1, None), height=50)
root.add_widget(toolbar)
slider = Slider(min=1., max=10., value=1.)
def update_depth_range(instance, value):
viewer.depth_range = value
slider.bind(value=update_depth_range)
toolbar.add_widget(slider)
button = Button(text='Use RGB shader')
def use_rgb(*l):
viewer.canvas.shader.fs = rgb_kinect
button.bind(on_press=use_rgb)
toolbar.add_widget(button)
button = Button(text='Use HSV shader')
def use_hsv(*l):
viewer.canvas.shader.fs = hsv_kinect
button.bind(on_press=use_hsv)
toolbar.add_widget(button)
return root
class SimResultScreen(BoxLayout):
def __init__(self, parentapp, simobj):
MINZOOM = 1
MAXZOOM = 10
super(SimResultScreen, self).__init__(orientation='vertical')
self.parentapp = parentapp
self.simobj = simobj
self.graphmodule = self.getGraphModule(simobj)
self.zoomslider = Slider(step=1,
orientation='horizontal',
min=MINZOOM,
max=MAXZOOM,
size_hint=(1, .1))
self.zoomslider.bind(value=self.onZoomSliderChange)
self.zoomslider.bind(value=self.onZoomVerticalSliderChange)
self.add_widget(self.graphmodule)
self.add_widget(self.zoomslider)
bottombar = BoxLayout(orientation='horizontal', size_hint=(1.0, 0.1))
datadumpbutton = Button(text='Save Result...')
datadumpbutton.bind(on_press=self.dumpcallback)
backbutton = Button(text='Back')
backbutton.bind(on_press=self.backcallback)
bottombar.add_widget(backbutton)
bottombar.add_widget(datadumpbutton)
self.add_widget(bottombar)
def getGraphModule(self, simobj):
respool = simobj.carmodel.respool
bat = respool.batteryChargeAh
g = SimUnitPlot('battery charge', bat)
#self.add_widget(g)
v = respool.velocityms
gv = SimUnitPlot('velocity', v)
return g
def backcallback(self, instance):
self.parentapp.showStartScreen()
def dumpcallback(self, instance):
#should refactor this into simobj.writeoutput or something. UI shouldn't really contain datadumping code, just call into it.
parentDirectory = dirname(dirname(abspath('__path__')))
targetDirectory = os.path.join(parentDirectory, "outputData")
if not os.path.isdir(targetDirectory):
os.mkdir(targetDirectory)
data = files.datadump.getCSVData(self.simobj.carmodel.respool)
files.datadump.dumpdata(os.path.join(targetDirectory, 'testdump.csv'),
data)
def onZoomSliderChange(self, instance, value):
self.graphmodule.setZoom(value)
return
def onZoomVerticalSliderChange(self, instance, value):
self.graphmodule.setZoomVertical(value)
return
def build(self):
from kivy.uix.slider import Slider
def test(*ars):
gauge.value = s.value
print(s.value)
def test_(*ars):
gauge_.value = s1.value
print(s.value)
def callback(instance):
if (instance == button1):
print("Change speed to 20km/hr")
gauge_.value = 20
elif (instance == button2):
print("Change speed to 60km/hr")
gauge_.value = 60
else:
print("Change speed to 100km/hr")
gauge_.value = 100
box = BoxLayout(orientation='horizontal', spacing=10, padding=10)
gauge_ = Gauge(value=150, size_gauge=256, size_text=19)
box.add_widget(gauge_)
s = Slider(min=0, max=140, value=0)
s1 = Slider(min=0, max=140, value=0)
s1.bind(value=test_)
box.add_widget(s1)
button1 = Button(text='20Km/hr',
font_size=14,
size_hint_x=0.3,
size_hint_y=0.2)
button2 = Button(text='60Km/hr',
font_size=14,
size_hint_x=0.3,
size_hint_y=0.2)
button3 = Button(text='100Km/hr',
font_size=14,
size_hint_x=0.3,
size_hint_y=0.2)
box.add_widget(button1)
button1.bind(on_press=callback)
box.add_widget(button2)
button2.bind(on_press=callback)
box.add_widget(button3)
button3.bind(on_press=callback)
return box
class AddAlarm(Button):
def mins_change(self, instance, value):
self.lblMins.text = str(round(value))
def hours_change(self, instance, value):
self.lblHours.text = str(round(value))
def addAlarm(self, instance):
alarms_list.append((self.lblHours.text, self.lblMins.text))
# create a new widget
new_alarm = Button(
text=str(self.lblHours.text) + ":" + str(self.lblMins.text),
size_hint=(.5, .25),
pos_hint={'y': .7499 - .25 * (len(alarms_list) - 1)})
alarmbox.add_widget(new_alarm)
self.time_setter.dismiss()
print(alarms_list)
def on_release(self):
# opens a popup window to choose your time
# the popup window contains dropdown menu to choose a time
# or better yet, just type the time in actually
# create two text inputs
layout = BoxLayout(orientation='vertical')
self.inHours = Slider(pos_hint={
'x': .1,
'center_y': .5
},
size_hint=(.7, .7),
value_track=True,
min=0,
max=23)
self.lblHours = Label(text=str(self.inHours.value))
self.inHours.bind(value=self.hours_change)
self.inMins = Slider(pos_hint={
'x': .1,
'center_y': .4
},
size_hint=(.7, .7),
value_track=True,
min=0,
max=59)
self.lblMins = Label(text=str(self.inMins.value))
self.inMins.bind(value=self.mins_change)
layout.add_widget(self.lblHours)
layout.add_widget(self.lblMins)
layout.add_widget(self.inHours)
layout.add_widget(self.inMins)
confirm = Button(text='confirm', size_hint=(.4, .4))
confirm.bind(on_press=self.addAlarm)
layout.add_widget(confirm)
self.time_setter = Popup(title='Set Alarm',
content=layout,
size_hint=(None, None),
size=(400, 400))
self.time_setter.open()
def build(self):
root = Widget()
puzzle = Puzzle(resolution=(640, 480), play=True)
slider = Slider(min=100, max=200, step=10, size=(800, 50))
slider.bind(value=partial(self.on_value, puzzle))
root.add_widget(puzzle)
root.add_widget(slider)
return root
def build(self):
self.root = BoxLayout(pos_hint={'center_x':.5, 'center_y':.5}, orientation='vertical')
self.svg = SvgWidget(size_hint_y=0.9)
self.root.add_widget(self.svg)
s = Slider(min=0, max=100, value=0, size_hint_y=0.1)
self.root.add_widget(s)
s.bind(value=self.on_value)
s.value=50
def go(self,screen):
if screen=="about":
cnt=BoxLayout(padding=0,spacing=0)
lbl=Label(text=" [size=20]pyPuzzle Game[/size]\n\nSimple fun memory game\n\n"
"Match simple jelly images\n\nEnter your scores.\n\n"
"www.yahyakesenek.com @2016",markup=True)
cnt.add_widget(lbl)
modal=ModalView(size_hint=(0.7,0.5),background_color=get_color_from_hex("#ff7373"))
modal.add_widget(cnt)
modal.open()
modal.x=self.root.x-modal.width-10
anim=Animation(center_x=self.root.center_x,center_y=self.root.center_y,d=2,t="out_expo")
anim.start(modal)
return
if screen=="settings":
cnt=BoxLayout()
lbl=Label(text="Set Sound Volume :")
sld=Slider(max=100,min=0,value=25)
sld.bind(value=self.value_change)
cnt.add_widget(lbl);cnt.add_widget(sld)
modal=ModalView(size_hint=(0.8,0.2),background_color=get_color_from_hex("#ff7373"))
modal.add_widget(cnt)
modal.open()
modal.x=self.root.x+modal.width+10
anim=Animation(center_x=self.root.center_x,center_y=self.root.center_y,d=2,t="out_expo")
anim.start(modal)
self.sld=sld
return
if screen=="exit":
cnt=BoxLayout(size_hint=(0.8,0.5),padding=4,spacing=5)
lbl=Label(text="[size=35][color=#ae5a41]Quit?[/color][/size]",markup=True)
btnyes=Button(text="Yes")
btnno=Button(text="No")
modal=ModalView(size_hint=(0.8,0.2))
def quit(inst):
exit()
def cancel(inst):
if modal:
modal.dismiss()
if self.root.current=="game_screen":
self.root.current_screen.newGame()
btnyes.bind(on_release=quit)
btnno.bind(on_release=cancel)
cnt.add_widget(lbl)
cnt.add_widget(btnyes)
cnt.add_widget(btnno)
modal.add_widget(cnt)
modal.open()
return
if screen=="end_screen":
self.level=1
self.root.current=screen
if self.root.current=="main_screen":
if self.snd.state=="stop":
self.snd.play()
else:
self.snd.stop()
def build(self):
root = Widget()
puzzle = Puzzle(resolution=(640, 480), play=True)
slider = Slider(min=100, max=200, step=10, size=(800, 50))
slider.bind(value=partial(self.on_value, puzzle))
root.add_widget(puzzle)
root.add_widget(slider)
return root
def stroke_popup(cls, painter, function): popup = cls(title='Set Stroke Size',title_align='center', size_hint = (None, None), size = (400, 200)) slider = Slider(value = painter.rad, value_track=True, value_track_color=[1,0,1,1], size_hint = (1.1, 1)) slider.range = (5, 50) slider.bind(on_touch_up=function) popup.add_widget(slider) return popup
def _get_form(self):
slider = Slider(id='value', min=self.min, max=self.max,
value=self.value, orientation=self.orientation)
slider.bind(value=self.setter('value'))
bind = self.bind
bind(min=slider.setter('min'))
bind(max=slider.setter('max'))
bind(value=slider.setter('value'))
bind(orientation=slider.setter('orientation'))
return slider
def build(self):
from kivy.uix.gridlayout import GridLayout
from kivy.uix.slider import Slider
import random
def test(*args):
lang_pizza.legend_value_rayon = slider_ray.value
fruit_pizza.legend_value_rayon = slider_ray.value
def rand(*args):
lang = ["Français", "Belge", "Anglais", "Allemand", "Italien"]
value = [25, 10, 15, 30, 20]
color = ['a9a9a9', '808080', '696969', '778899', '708090']
random.shuffle(lang)
random.shuffle(value)
random.shuffle(color)
lang_pizza.serie = zip(lang, value, color)
layout = GridLayout(cols=2, padding=50)
lang_pizza = Pizza(serie=[
["Français", 5, 'a9a9a9'],
["Belge", 25, '808080'],
["Anglais", 20, '696969'],
["Allemand", 30, '778899'],
["Italien", 20, '708090']],
chart_size=256,
legend_color='ffffcc',
legend_value_rayon=100,
legend_title_rayon=170,
chart_border=2)
fruit_pizza = Pizza(serie=[
["Pomme", 20, '6495ed'],
["Poire", 20, '7b68ee'],
["Abricot", 20, '4169e1'],
["Prune", 20, '0000ff'],
["Ananas", 20, '00008b']],
chart_size=256,
legend_color='ffffcc',
legend_value_rayon=100,
legend_title_rayon=170,
chart_border=2)
slider_v = Slider(min=0, max=300, value=50)
slider_v.bind(value=rand)
slider_ray = Slider(min=0, max=250, value=100)
slider_ray.bind(value=test)
layout.add_widget(lang_pizza)
layout.add_widget(fruit_pizza)
layout.add_widget(slider_v)
layout.add_widget(slider_ray)
return layout
def build(self):
root = Widget()
print(root.height,root.width)
puzzle = Camera(size=(480, 320), resolution=(480, 320), play=True, allow_stretch=True)
print("The camera is a {}".format(puzzle))
slider = Slider(min=100, max=400, step=10, size=(800, 50))
slider.value=100
slider.bind(value=partial(self.on_value, puzzle))
root.add_widget(puzzle)
root.add_widget(slider)
return root
def addSettingsView(self):
"""
creates settings view and adds it to SettingsPanel layout
:return:
"""
layout = FloatLayout(size_hint = (1.0, 0.6))
# item position Y coordinates
firstRowY = 0.85
secondRowY = 0.750
thirdRowY = 0.70
fourthRowY = 0.60
self.addLabel(layout, "Sort By:", 0.5, 0.90)
self.addLabel(layout, "NAME", 0.15, firstRowY)
self.addLabel(layout, "OR", 0.5, firstRowY)
self.addLabel(layout, "PRICE", 0.85, firstRowY)
self.addLabel(layout, "IN", 0.5, secondRowY )
self.addLabel(layout, "DESCEND", 0.85, thirdRowY )
self.addLabel(layout, "OR", 0.5, thirdRowY)
self.addLabel(layout, "ASCEND", 0.15, thirdRowY)
self.addLabel(layout, "USING", 0.5, fourthRowY)
self.addLabel(layout, "TIME: ", 0.15, 0.2)
self.timeLabel = self.addLabel(layout, "0 seconds", 0.43, 0.2)
self.checkbox = CheckBox(pos_hint = {"center_x" : 0.370, "center_y" : firstRowY}, size_hint = (0.1, 0.1))
self.checkbox.bind(active = self.nameCheckbox)
layout.add_widget(self.checkbox)
self.checkbox = CheckBox(pos_hint = {"center_x" : 1-0.370, "center_y" : firstRowY}, size_hint = (0.1, 0.1))
self.checkbox.bind(active = self.priceCheckbox)
layout.add_widget(self.checkbox)
self.checkbox = CheckBox(pos_hint = {"center_x" : 0.370, "center_y" : thirdRowY}, size_hint = (0.1, 0.1))
self.checkbox.bind(active = self.ascendingCheckbox)
layout.add_widget(self.checkbox)
self.checkbox = CheckBox(pos_hint = {"center_x" : 1-0.370, "center_y" : thirdRowY}, size_hint = (0.1, 0.1))
self.checkbox.bind(active = self.descendingCheckbox)
layout.add_widget(self.checkbox)
spinner = Spinner(
text='Sort algorithm...',
values=('Insertion sort', 'Bubble sort'),
size_hint=(1.0, 0.1),
pos_hint={'center_x': .5, 'center_y': .5})
spinner.bind(text=self.algorithmSelection)
layout.add_widget(spinner)
button = Button(on_press=self.startButton, text="START", pos_hint={"center_x":0.5, "bottom":0.0}, size_hint=(1.0,0.1))
layout.add_widget(button)
slider = Slider(min= 0, max= 60, step=1, value=0, pos_hint = {"center_x" : 0.5, "center_y" : 0.3}, size_hint=(1.0,0.2))
slider.bind(value=self.slider)
layout.add_widget(slider)
self.addToPanel(layout)
class RootWidget(BoxLayout):
def __init__(self, **kwargs):
super(RootWidget, self).__init__(padding=50)
self.label=Label(text="Please slide the slider")
self.add_widget(self.label)
self.slider = Slider(min=-100, max=100, value=25)
self.slider.bind(value=self.callback)
self.add_widget(self.slider)
def callback(self,instance,value):
self.label.text=str(value)
def __init__(self, **kwargs):
super().__init__(**kwargs)
info = BoxLayout(orientation='vertical')
logo = Label(text="MasterGrid")
info.add_widget(logo)
layout = Button(text=self.get_layout())
layout.bind(on_release=self.switch_layout)
info.add_widget(layout)
self.add_widget(info)
menu = Button(text="Settings")
menu.bind(on_press=app.open_settings)
self.add_widget(menu)
pitchbend = ToggleButton(text="Pitchbend", state=self.get('Pitchbend'))
pitchbend.bind(on_release=partial(self.set, 'Pitchbend'))
self.add_widget(pitchbend)
aftertouch = ToggleButton(text="Aftertouch", state=self.get('Aftertouch'))
aftertouch.bind(on_release=partial(self.set, 'Aftertouch'))
self.add_widget(aftertouch)
octave = Sizer(section='Grid', label='Octave', orientation='vertical', low=0, high=8)
self.add_widget(octave)
rows = Sizer(section='Grid', label='Rows', orientation='vertical', low=8, high=36)
self.add_widget(rows)
keys = Sizer(section='Grid', label='Keys', orientation='vertical', low=8, high=36)
self.add_widget(keys)
prog = Sizer(section='MIDI', label='Instrument', orientation='vertical', low=0, high=127)
self.add_widget(prog)
mod = BoxLayout(orientation='vertical')
mod_label = Label(text="Modulation")
mod_slider = Slider(min=0, max=127)
mod_slider.bind(value=self.set_mod)
mod.add_widget(mod_label)
mod.add_widget(mod_slider)
self.add_widget(mod)
reverb = BoxLayout(orientation='vertical')
reverb_label = Label(text="Reverb")
reverb_slider = Slider(min=0, max=127)
reverb_slider.bind(value=self.set_reverb)
reverb.add_widget(reverb_label)
reverb.add_widget(reverb_slider)
self.add_widget(reverb)
panic = Button(text="Panic", on_press=self.panic)
self.add_widget(panic)
def create_settings_controllers():
#crate a horizontal boxlayout to include label, slider and input box
brightness_controller = BoxLayout(orientation = 'horizontal', size_hint_y = 0.1)
brightness_label = Label(text = 'Brightness', size_hint_x = 0.2)
brightness_slider = Slider(min=0, max=64, value= 1, size_hint_x = 0.5)
brightness_input = TextInput(text = '50', multiline = False, size_hint_x = 0.3)
# add widgets to the boxlayout (controller)
for i in [brightness_label, brightness_slider, brightness_input]:
brightness_controller.add_widget(i)
#contrast control
contrast_controller = BoxLayout(orientation = 'horizontal', size_hint_y = 0.1)
contrast_label = Label(text = 'Contrast', size_hint_x = 0.2)
contrast_slider = Slider(min=0, max=64, value= 1, size_hint_x = 0.5)
contrast_input = TextInput(text = '50', multiline = False, size_hint_x = 0.3)
for i in [contrast_label, contrast_slider, contrast_input]:
contrast_controller.add_widget(i)
def settings_slider_control(instance,value):
"""single feedback for sliders to control brightness, contrast, etc"""
if instance == brightness_slider:
brightness_input.text = str(instance.value)
elif instance == contrast_slider:
contrast_input.text = str(instance.value)
def settings_input_control(instance):
"""single feedback for input box to control brightness, contrast, etc"""
# make sure the input does not go beyond range
if float(instance.text) > brightness_slider.max:
instance.text = str(brightness_slider.max)
elif float(instance.text) < brightness_slider.min:
instance.text = str(brightness_slider.min)
if instance == brightness_input:
brightness_slider.value = float(brightness_input.text)
if float(instance.text) > contrast_slider.max:
instance.text = str(contrast_slider.max)
elif float(instance.text) < contrast_slider.min:
instance.text = str(contrast_slider.min)
if instance == contrast_input:
contrast_slider.value = float(contrast_input.text)
brightness_slider.bind(value = settings_slider_control)
brightness_input.bind(on_text_validate = settings_input_control)
contrast_slider.bind(value = settings_slider_control)
contrast_input.bind(on_text_validate = settings_input_control)
return brightness_controller, contrast_controller
class AudioApp(App):
def build(self):
self.stream = get_output(channels=CHANNELS, buffersize=BUFSIZE, rate=22050)
self.slider = Slider(min=110, max=880, value=440)
self.slider.bind(value=self.update_freq)
self.source = SineSource(self.stream, 440)
self.source.start()
return self.slider
def update_freq(self, slider, value):
#value = int(value / 50) * 50
if value != self.source.frequency:
self.source.frequency = value
def build(self):
box = BoxLayout(orientation='horizontal', padding=5)
self.gauge = Gauge(value=50, size_gauge=256, size_text=25)
self.slider = Slider(orientation='vertical')
stepper = Slider(min=1, max=25)
stepper.bind(
value=lambda instance, value: setattr(self, 'step', value)
)
box.add_widget(self.gauge)
box.add_widget(stepper)
box.add_widget(self.slider)
Clock.schedule_interval(lambda *t: self.gauge_increment(), 0.03)
return box
class VCSSlider(BoxLayout):
value = NumericProperty(1)
def __init__(self, osc_address, show_value=False,
min=0, max=100, step=1, **kwargs):
super(VCSSlider, self).__init__(**kwargs)
self.osc_address = osc_address
self.show_value = show_value
self.orientation = 'vertical'
self.slider = Slider(
orientation='vertical',
size_hint_y=0.8,
min=min,
max=max,
step=step)
self.slider.bind(value=self.slider_moved)
label = Label(
text=self.osc_address.replace('_', ' ').lstrip('/'),
size_hint_y=0.2)
if self.show_value:
self.value_label = Label(
size_hint_y=0.1,
text=str(min))
self.add_widget(self.value_label)
self.add_widget(self.slider)
self.add_widget(label)
def on_value(self, instance, value):
self.slider.value = self.value
def slider_moved(self, instance, value):
send_osc_message(self.osc_address, [self.slider.value_normalized])
self.value = self.slider.value
if self.show_value:
value_string = str(self.value)
if value_string.endswith('.0'):
value_string = value_string[:-2]
self.value_label.text = value_string
def add_slider(self):
"""
add sliders
"""
box1 = BoxLayout(orientation="vertical", size = (150, 110), pos = (Window.width * 2/7, 0))
box2 = BoxLayout(orientation="vertical", size = (380, 110), pos = (Window.width * 1/2, 0))
# Cohesion
slider1 = Slider(min=0, max=1, value = self.cohesion_weight, step = 0.1)
label1 = Label(text = "Cohesion: " + str(slider1.value), color = (0,0,0,1))
# Alignment
slider2 = Slider(min=0, max=1, value = self.alignment_weight, step = 0.1)
label2 = Label(text = "Alignment: " + str(slider2.value), color = (0,0,0,1))
# Separation
slider3 = Slider(min=0, max=1, value = self.separation_weight, step = 0.1)
label3 = Label(text = "Separation: " + str(slider3.value), color = (0,0,0,1))
# Field of View
slider4 = Slider(min=0, max=180, value = self.view_angle * 2, step = 1)
label4 = Label(text = "Field of View (degree): " + str(slider4.value), color = (0,0,0,1))
# bind slider value to label
def on_value1(object, value):
self.cohesion_weight = float(value)
label1.text = "Cohesion: " + str(float(value))
def on_value2(object, value):
self.alignment_weight = float(value)
label2.text = "Alignment: "+ str(float(value))
def on_value3(object, value):
self.separation_weight = float(value)
label3.text = "Separation: " + str(value)
def on_value4(object, value):
self.view_angle = float(value)
label4.text = "Field of View (degree): " + str(value)
slider1.bind(value = on_value1)
slider2.bind(value = on_value2)
slider3.bind(value = on_value3)
slider4.bind(value = on_value4)
# add widgets to screen
box1.add_widget(label1)
box2.add_widget(slider1)
box1.add_widget(label2)
box2.add_widget(slider2)
box1.add_widget(label3)
box2.add_widget(slider3)
box1.add_widget(label4)
box2.add_widget(slider4)
self.add_widget(box1)
self.add_widget(box2)
def _create_formatting(self):
f_label_text = 'Highlight first {} characters:'
f_label = self.wf.get_label(f_label_text.format(12))
def binding(slider, value):
f_label.text = f_label_text.format(int(value))
if value == self.FORMAT_BORDER_MAX:
f_label.text = 'Highlight all'
self._show_hash()
f_slider = Slider(
min=1, max=self.FORMAT_BORDER_MAX, step=1, value=12, padding='0dp')
f_slider.bind(value=binding)
self.add_widget(f_label)
self.add_widget(f_slider)
return f_slider
def start(self, value):
print("Start Game")
self.background_sound.play()
self.content.clear_widgets()
if(self.type == 'IMAGE'):
puzzles_images = glob.glob( "assets/graphics/puzzles/*.jpg" )
puzzle = game.get_game_type(Image)(source=random.choice(puzzles_images))
else:
puzzle = game.get_game_type(Camera)(resolution=(640, 480), play=True)
slider = Slider(min=100, max=200, step=10, size=(800, 50))
self.content.add_widget(puzzle)
slider.bind(value=partial(self.on_value, puzzle))
self.content.add_widget(slider)
def __init__(self, **kwargs):
super(NumComponentsSelect, self).__init__(**kwargs)
self.numComponents = Label(text='Number of components: ', pos=(0, 250))
# self.numComponents.bind(value=self.sliderChange)
compSlider = Slider(min=1, max=109, value=25, pos=(0, 200))
compSlider.bind(value=self.sliderChange)
self.add_widget(self.numComponents)
self.add_widget(compSlider)
# after images
layout = FloatLayout()
self.before1 = Image(source='face1.png', pos=(-300, 100))
self.before2 = Image(source='face2.png', pos=(-170, 100))
layout.add_widget(self.before1)
layout.add_widget(self.before2)
self.add_widget(layout)
def _connect(self, ins, optname):
settings = App.get_running_app().settings
minval = settings.property(optname).get_min(settings)
maxval = settings.property(optname).get_max(settings)
value = getattr(settings, optname)
slider = Slider(value=value, min=minval, max=maxval)
label = Label(text=self._tostr(value), halign='left', size_hint_x=0.3)
def on_value(ins, value):
value = _clamp(value, minval, maxval)
label.text = self._tostr(value)
setattr(settings, optname, self._totype(value))
slider.bind(value=on_value)
self.add_widget(slider)
self.add_widget(label)
def game_over(self, game_starting=False):
# calculate score
score = str(self.score[0]) + '-' + str(self.score[1])
print "done!", score
self.save_level()
content2 = BoxLayout(orientation='vertical', spacing=10)
# content.add_widget(Label(text='score: %d'%int(score)))
content = BoxLayout(orientation='vertical', size_hint_y=.7)
# change show time
label_slider = LabelTimeSlider(text='Initial Show time: %s s'%self.level)
content.add_widget(label_slider)
new_level = Slider(min=1, max=30, value=self.level)
content.add_widget(new_level)
new_level.bind(value=label_slider.update)
new_level.bind(value=self.reset_time)
# change number of items
label_nb = LabelNb(text='Number of items: %s'%self.items)
content.add_widget(label_nb)
nb_items = Slider(min=5, max=MAX_NBITEMS, value=self.items)
content.add_widget(nb_items)
nb_items.bind(value=label_nb.update)
nb_items.bind(value=self.reset_nb_item)
content2.add_widget(content)
if game_starting:
replay_btn = Button(text='Play!')
else:
replay_btn = Button(text='Replay!')
credits_btn = Button(text='Credits')
action = BoxLayout(orientation='horizontal', size_hint_y=.3)
action.add_widget(replay_btn)
action.add_widget(credits_btn)
content2.add_widget(action)
if game_starting:
greeting = "Welcome to Pro Soccer Mem 15. Choose your game mode:"
elif self.score[0] > self.score[1]:
greeting = "Congratulations!" + ' Your score was: %s' % str(score)
elif self.score[1] > self.score[0]:
greeting = "Oh no! You've been defeated." + ' Your score was: %s' % str(score)
else:
greeting = "What a game, it was a tie!" + ' Your score was: %s' % str(score)
popup = PopupGameOver(title=greeting,
content=content2,
size_hint=(0.5, 0.5), pos_hint={'x': 0.25, 'y': 0.25},
auto_dismiss=False)
replay_btn.bind(on_press=popup.replay)
replay_btn.bind(on_press=self.restart_game)
credits_btn.bind(on_press=popup.credits)
popup.open()
def create_step_slider():
"""Manipulate step of motor movement"""
step_slider_label = Label(
text='Motor Steps: \n'+'{}'.format(100), markup=True,
color = [0.2,0.2,1,1], halign = 'center', valign = 'middle',
size_hint_y = 0.05)
step_slider = Slider(
min=0, max=1000, value= 100,
orientation = 'vertical', size_hint_y = 0.4)
def motor_step_control(instance, value):
"""change step and update label when using step_slider"""
slider_value = int(value)
step_slider_label.text = 'Motor Steps: \n'+'{}'.format(slider_value)
print (value)
step_slider.bind(value = motor_step_control)
return step_slider_label, step_slider
def build(self):
root = BoxLayout(orientation='vertical')
self.viewer = viewer = KinectViewer(
index=self.config.getint('kinect', 'index'),
shader=self.config.get('shader', 'theme'))
root.add_widget(viewer)
toolbar = BoxLayout(size_hint=(1, None), height=50)
root.add_widget(toolbar)
slider = Slider(min=1., max=32., value=1.)
def update_depth_range(instance, value):
viewer.depth_range = value
slider.bind(value=update_depth_range)
toolbar.add_widget(slider)
return root
