def __init__(self, space_game, **kwargs):
kwargs['orientation'] = 0
SpaceShip.__init__(self, space_game, **kwargs)
self.score = 0
self.gun_fire_interval = 0.1
if self._keyboard == None and platform not in ("android", "ios"):
self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_key_down)
self._keyboard.bind(on_key_up=self._on_key_up)
self.gun = RepeaterGun(space_game=self.space_game)
self.add_widget(self.gun)
self.gun.center_x = self.center_x
self.gun.center_y = self.center_y
self.boom = load_sound('sounds/boom.ogg', volume=FX_VOLUME)
# Add touch events layer
self.player_speed = Vector(0, 0)
self.bullet_rate = 0.0
self.player_motion = None
self.bullet_fire = None
touch_layer = FloatLayout(pos_hint=(0, 0), size_hint=(1., 1.))
touch_layer.bind(
on_touch_down=self.on_touch_down,
on_touch_move=self.on_touch_move,
on_touch_up=self.on_touch_up,
)
self.add_widget(touch_layer)
self._update_event = Clock.schedule_interval(self.update, FPS)
def build(self):
# 设置背景尺寸（布局）
def update_rect(layout, *args):
# 布局矩形位置 = 布局位置
layout.rect.pos = layout.pos
# 布局矩形大小 = 布局大小
layout.rect.size = layout.size
# 浮动布局
float_layout = FloatLayout()
# 浮动布局画布锁
with float_layout.canvas:
# 背景颜色
Color(1, 1, 1, 1)
# 浮动布局矩形 = 矩形（位置=浮动布局位置，大小=浮动布局大小）
float_layout.rect = Rectangle(pos=float_layout.pos, size=float_layout.size)
# 浮动布局绑定（位置=布局矩形位置，大小=设置背景尺寸）
float_layout.bind(pos=update_rect, size=update_rect)
# 在布局内的300，200处添加一个为布局0.3，0.2大小的按钮
button = Button(text='Hello FloatLayout', size_hint=(.3, .2), pos=(300, 200))
# 布局加组件（按钮）
float_layout.add_widget(button)
# 返回布局
return float_layout
class Test(App):
def create_clock(self, widget, touch, *args):
callback = partial(self.menu, touch)
Clock.schedule_once(callback, 2)
touch.ud['event'] = callback
def delete_clock(self, widget, touch, *args):
Clock.unschedule(touch.ud['event'])
def menu(self, touch, *args):
menu = BoxLayout(size_hint=(None, None),
orientation='vertical',
center=touch.pos)
menu.add_widget(Button(text='a'))
menu.add_widget(Button(text='b'))
close = Button(text='close')
close.bind(on_release=partial(self.close_menu, menu))
menu.add_widget(close)
self.root.add_widget(menu)
def close_menu(self, widget, *args):
self.root.remove_widget(widget)
def build(self):
self.root = FloatLayout()
self.root.bind(on_touch_down=self.create_clock,
on_touch_up=self.delete_clock)
def buildW(self):
print("ScreenWidgets.buildW")
print("- screens now count is", self.screens)
self.fls = []
self.screenObjs = []
self.flsOrgs = []
self.navBts = []
self.navAddBts = []
for si in range(self.screens):
screen = Screen(name="Widgets%s" % si)
self.screenObjs.append(screen)
self.flsOrgs.append(None)
fl = FloatLayout()
fl.bind(size=self.flChangeSize)
self.fls.append(fl)
#fl.add_widget(Label(text="widgets%s"%si))
#self.flsOrgs[si] = fl.on_touch_down
#fl.on_touch_down = self.on_touch
screen.add_widget(fl)
try:
self.setUpGui(si, fl, self.wConfig[si])
except:
self.setUpGui(si, fl, [])
self.gui.rl.add_widget(screen)
self.flChangeSize(b=fl.size)
print(" DONE")
class Test(App):
def create_clock(self, widget, touch, *args):
callback = partial(self.menu, touch)
Clock.schedule_once(callback, 2)
touch.ud['event'] = callback
def delete_clock(self, widget, touch, *args):
Clock.unschedule(touch.ud['event'])
def menu(self, touch, *args):
menu = BoxLayout(
size_hint=(None, None),
orientation='vertical',
center=touch.pos)
menu.add_widget(Button(text='a'))
menu.add_widget(Button(text='b'))
close = Button(text='close')
close.bind(on_release=partial(self.close_menu, menu))
menu.add_widget(close)
self.root.add_widget(menu)
def close_menu(self, widget, *args):
self.root.remove_widget(widget)
def build(self):
self.root = FloatLayout()
self.root.bind(
on_touch_down=self.create_clock,
on_touch_up=self.delete_clock)
def build(self):
root = FloatLayout()
self.btn = Button()
self.btn.pos_hint = {"center_x": .5, "center_y": .5}
self.btn.size_hint = [.5, .5]
root.add_widget(self.btn)
root.bind(on_touch_down=self.check_collision)
return root
def create_top_bar(self):
top_bar = FloatLayout(size_hint=(1, None), size=(1000, 60))
with top_bar.canvas.before:
top_bar.rect = Image(source=BKGD_LCHRC,
keep_ratio=False,
allow_stretch=True,
size_hint=(1, 1))
top_bar.bind(pos=self.update_rect, size=self.update_rect)
self.page_layout.add_widget(top_bar)
return top_bar
def build(self):
root = FloatLayout()
renderer = Renderer()
btn = Button(size_hint=(None, None), size=root.size, text="Hello world", pos=(0, 0), font_size="120dp")
root.add_widget(btn)
root.add_widget(renderer)
#root.add_widget(btn)
def _on_resize(inst, value):
btn.size = value
root.bind(size=_on_resize)
return root
def build(self):
root = FloatLayout()
renderer = Renderer()
btn = Button(size_hint=(None, None), size=root.size, text="Hello world", pos=(0, 0), font_size="120dp")
root.add_widget(btn)
root.add_widget(renderer)
#root.add_widget(btn)
def _on_resize(inst, value):
btn.size = value
root.bind(size=_on_resize)
return root
class ForestFireDetect(App):
icon = 'flame-icon.png'
def create_clock(self, widget, touch, *args):
callback = partial(self.menu, touch)
Clock.schedule_once(callback, 2)
touch.ud['event'] = callback
def delete_clock(self, widget, touch, *args):
Clock.unschedule(touch.ud['event'])
def menu(self, touch, *args):
menu = BoxLayout(
size_hint=(None, None),
orientation='vertical',
center=touch.pos)
Button1 = Button(text='C: Forest Fire Analysis of Gujarat',size=(2,2))
Button1.bind(on_release=f)
Button2 = Button(text='B: Global Fire Plot')
Button2.bind(on_release=g)
Button3 = Button(text='A: High Res Satellite Image')
Button3.bind(on_release=h)
close = Button(text='Close')
close.bind(on_release=partial(self.close_menu, menu))
menu.add_widget(Button3)
menu.add_widget(Button2)
menu.add_widget(Button1)
menu.add_widget(close)
self.root.add_widget(menu)
def close_menu(self, widget, *args):
self.root.remove_widget(widget)
def build(self):
self.root = FloatLayout()
self.root.bind(
on_touch_down=self.create_clock,
on_touch_up=self.delete_clock)
def loading():
Window.clearcolor = (1, 140.0 / 255, 15.0 / 255, 0)
#Window.fullscreen=True
f = FloatLayout()
title = Label(text='Trages',
markup=True,
bold=True,
color=(79.0 / 255, 15.0 / 255, 204.0 / 255, 0),
font_name='RAVIE.ttf',
halign='center',
font_size='100dp',
padding_y=2 * Window.height / 6)
img = Image(source='hand.png', keep_data=True)
img.y = Window.height / 6
f.bind(on_touch_down=_on_touch_down)
f.add_widget(title)
f.add_widget(img)
return f
def loading():
Window.clearcolor=(1,140.0/255,15.0/255,0)
#Window.fullscreen=True
f=FloatLayout()
title = Label(
text='Trages',
markup=True,
bold=True,
color=(79.0/255,15.0/255,204.0/255,0),
font_name='RAVIE.ttf',
halign='center',
font_size='100dp',
padding_y=2*Window.height/6
)
img=Image(source='hand.png',keep_data=True)
img.y=Window.height/6
f.bind(on_touch_down=_on_touch_down)
f.add_widget(title)
f.add_widget(img)
return f
class MainScreen(Screen):
def __init__(self, **kwargs):
super(MainScreen, self).__init__(**kwargs)
import Tkinter
root = Tkinter.Tk()
self.WIN_WIDTH, self.WIN_HEIGHT = root.winfo_screenwidth(
), root.winfo_screenheight()
self.MIL_WIDTH, self.MIL_HEIGHT = root.winfo_screenmmwidth(
), root.winfo_screenmmheight()
self.PPC = 10. * (float(self.WIN_WIDTH) / self.MIL_WIDTH +
float(self.WIN_HEIGHT) / self.MIL_HEIGHT) / 2.
self.SCREEN_INFO = (self.WIN_WIDTH, self.WIN_HEIGHT, self.MIL_WIDTH,
self.MIL_HEIGHT, self.PPC)
self.capture = cv2.VideoCapture(0)
self.capture.set(3, self.WIN_WIDTH)
self.capture.set(4, self.WIN_HEIGHT)
self.eyeTracker = None
try:
self.eyeTracker = pylink.EyeLink('100.1.1.1')
except:
self.eyeTracker = None
print "Could not connect to eye tracker"
''' Layout the layouts '''
self.mainLayout = mainLayout = FloatLayout()
with mainLayout.canvas.before:
Color(.8, .8, .8, 1)
self.background = Rectangle(size=self.size, pos=self.pos)
mainLayout.bind(pos=self._updateBackground,
size=self._updateBackground)
hgap, vgap = 0.01, 0.01
self.topLeftLayout = topLeftLayout = PartialLayout(
size_hint=(.5 - hgap / 2, 0.4 * (1 - 2 * vgap)),
pos_hint={
'center_x': 0.25 - hgap / 4,
'center_y': .804
})
self.middleLeftLayout = middleLeftLayout = PartialLayout(
size_hint=(.5 - hgap / 2, 0.5 * (1 - 2 * vgap)),
pos_hint={
'center_x': 0.25 - hgap / 4,
'center_y': .353
})
self.bottomLeftLayout = bottomLeftLayout = PartialLayout(
size_hint=(.5 - hgap / 2, 0.1 * (1 - 2 * vgap)),
pos_hint={
'center_x': 0.25 - hgap / 4,
'center_y': .049
})
self.rightLayout = rightLayout = PartialLayout(size_hint=(.5 -
hgap / 2, 1),
pos_hint={
'center_x':
0.75 + hgap / 4,
'center_y':
.5
})
self.add_widget(mainLayout)
mainLayout.add_widget(topLeftLayout)
mainLayout.add_widget(middleLeftLayout)
mainLayout.add_widget(bottomLeftLayout)
mainLayout.add_widget(rightLayout)
''' Top left layout '''
saveFolderLabel = Label(text='Save Folder',
size_hint=(0.4, 0.25),
pos_hint={
'center_x': 0.2,
'center_y': 0.875
})
folderButton = Button(source='Assets/folder.png',
size_hint=(None, None),
size=(0.05 * self.WIN_HEIGHT,
0.05 * self.WIN_HEIGHT),
pos_hint={
'center_x': 0.45,
'center_y': 0.875
})
self.folderText = TextInput(size_hint=(0.5, 0.125),
pos_hint={
'center_x': 0.75,
'center_y': 0.875
})
subjectIDLabel = Label(text='Subject ID',
size_hint=(0.5, 0.25),
pos_hint={
'center_x': 0.25,
'center_y': 0.625
})
self.subjectIDText = TextInput(size_hint=(0.5, 0.125),
pos_hint={
'center_x': 0.75,
'center_y': 0.625
})
calibButton = Button(text='Calibrate Eye Tracker',
size_hint=(1, 0.25),
pos_hint={
'center_x': 0.5,
'center_y': 0.375
})
checkCamButton = Button(text='Check Camera',
size_hint=(1, 0.25),
pos_hint={
'center_x': 0.5,
'center_y': 0.125
})
folderButton.background_normal = 'Assets/folder_normal.png'
folderButton.background_down = 'Assets/folder_down.png'
topLeftLayout.add_widget(saveFolderLabel)
topLeftLayout.add_widget(folderButton)
topLeftLayout.add_widget(self.folderText)
topLeftLayout.add_widget(subjectIDLabel)
topLeftLayout.add_widget(self.subjectIDText)
topLeftLayout.add_widget(calibButton)
topLeftLayout.add_widget(checkCamButton)
''' Middle Left Layout '''
designerLabel = Label(text='Experiment Designer',
size_hint=(1, 0.2),
pos_hint={
'center_x': 0.5,
'center_y': 0.9
})
self.asd = asd = AntisaccadeDesigner(size_hint=(1, 0.39),
pos_hint={
'center_x': 0.5,
'center_y': 0.6
})
self.vsd = vsd = VisualSearchDesigner(size_hint=(1, 0.39),
pos_hint={
'center_x': 0.5,
'center_y': 0.2
})
middleLeftLayout.add_widget(designerLabel)
middleLeftLayout.add_widget(asd)
middleLeftLayout.add_widget(vsd)
''' Bottom Left Layout '''
startButton = Button(text='Start',
size_hint=(0.5, 0.99),
pos_hint={
'center_x': 0.5,
'center_y': 0.5
})
bottomLeftLayout.add_widget(startButton)
''' Right Layout '''
self.stimGrid = GridLayout(cols=1, spacing=10, size_hint_y=None)
self.stimGrid.bind(minimum_height=self.stimGrid.setter('height'))
with self.stimGrid.canvas.before:
Color(0, 0, 0, 1)
self.gridRect = Rectangle(size=self.stimGrid.size,
pos=self.stimGrid.pos)
self.stimGrid.bind(pos=self._updateGridRect, size=self._updateGridRect)
flowLabel = Label(text='Experiment Flow',
size_hint=(1, 0.1),
pos_hint={
'center_x': 0.5,
'center_y': 0.95
})
scroller = ScrollView(size_hint=(1, 0.7),
pos_hint={
'center_x': 0.5,
'center_y': 0.55
})
showButton = Button(text='Hide',
size_hint=(0.5, 0.1),
pos_hint={
'center_x': 0.25,
'center_y': 0.15
})
clearButton = Button(text='Clear',
size_hint=(0.5, 0.1),
pos_hint={
'center_x': 0.75,
'center_y': 0.15
})
randButton = Button(text='Randomize',
size_hint=(0.5, 0.1),
pos_hint={
'center_x': 0.25,
'center_y': 0.05
})
scroller.add_widget(self.stimGrid)
rightLayout.add_widget(flowLabel)
rightLayout.add_widget(scroller)
rightLayout.add_widget(showButton)
rightLayout.add_widget(clearButton)
rightLayout.add_widget(randButton)
''' Other widgets '''
self.isVisible = True
self.coverWidget = FloatLayout(size_hint=(1, 0.7),
pos_hint={
'center_x': 0.5,
'center_y': 0.55
})
with self.coverWidget.canvas.before:
Color(0, 0, 0, 1)
self.coverRect = Rectangle(size=self.coverWidget.size,
pos=self.coverWidget.pos)
self.coverWidget.bind(pos=self._updateCoverRect,
size=self._updateCoverRect)
self.coverWidget.add_widget(
Label(text='Experiment flow is\ncurrently hidden.',
size_hint=(1, 1),
pos_hint={
'center_x': 0.5,
'center_y': 0.5
}))
self.calibrationWidget = FloatLayout(size_hint=(1, 1),
pos_hint={
'center_x': 0.5,
'center_y': 0.5
})
with self.calibrationWidget.canvas.before:
Color(0, 0, 0, 1)
self.calibRect = Rectangle(size=self.calibrationWidget.size,
pos=self.calibrationWidget.pos)
self.calibrationWidget.bind(pos=self._updateCalibOverlay,
size=self._updateCalibOverlay)
self.coverWidget.add_widget(
Label(text=CALIB_TEXT,
size_hint=(1, 1),
pos_hint={
'center_x': 0.5,
'center_y': 0.5
}))
''' Object Bindings '''
folderButton.bind(on_release=self.chooseRootFolder)
checkCamButton.bind(on_release=self.toCheckCam)
calibButton.bind(on_release=self.calibrateEyelink)
self.asd.addButton.bind(on_release=self.addAntisaccade)
self.vsd.addButton.bind(on_release=self.addVisualSearch)
startButton.bind(on_release=self.startExperiment)
showButton.bind(on_release=self.toggleGUI)
clearButton.bind(on_release=self.clearExperiment)
randButton.bind(on_release=self.randomizeOrder)
def chooseRootFolder(self, _):
pass
def calibrateEyelink(self, _):
if not self.eyeTracker is None:
self.eyeTracker.doTrackerSetup()
def toCheckCam(self, _):
self.parent.transition.direction = 'left'
self.parent.current = 'check_cam'
def addAntisaccade(self, _):
stimLabel = StimLabel(text='Antisaccade',
size_hint_y=None,
height=self.WIN_HEIGHT / 10)
self.stimGrid.add_widget(stimLabel)
stimLabel.buttonUp.bind(on_release=self.moveTaskUp)
stimLabel.buttonDown.bind(on_release=self.moveTaskDown)
stimLabel.buttonRemove.bind(on_release=self.removeTask)
def addVisualSearch(self, _):
text = 'Visual Search\nContrast(s): {}, Stimuli: {}'.format(
self.vsd.mainContrastButton.text.split(' ')[0],
self.vsd.mainConditionButton.text.split(' ')[0])
stimLabel = StimLabel(text=text,
size_hint_y=None,
height=self.WIN_HEIGHT / 10)
self.stimGrid.add_widget(stimLabel)
stimLabel.buttonUp.bind(on_release=self.moveTaskUp)
stimLabel.buttonDown.bind(on_release=self.moveTaskDown)
stimLabel.buttonRemove.bind(on_release=self.removeTask)
def moveTaskUp(self, obj):
index = self.stimGrid.children.index(obj.parent.parent)
if index == len(self.stimGrid.children) - 1:
return
child = self.stimGrid.children[index]
self.stimGrid.remove_widget(child)
self.stimGrid.add_widget(child, index + 1)
def moveTaskDown(self, obj):
index = self.stimGrid.children.index(obj.parent.parent)
if index == 0:
return
child = self.stimGrid.children[index]
self.stimGrid.remove_widget(child)
self.stimGrid.add_widget(child, index - 1)
def removeTask(self, obj):
self.stimGrid.remove_widget(obj.parent.parent)
def startExperiment(self, _):
if len(self.stimGrid.children) == 0:
return
def toggleGUI(self, _):
if self.isVisible:
self.rightLayout.add_widget(self.coverWidget)
else:
self.rightLayout.remove_widget(self.coverWidget)
self.isVisible = not self.isVisible
def clearExperiment(self, _):
self.stimGrid.clear_widgets()
def randomizeOrder(self, _):
random.shuffle(self.stimGrid.children)
def _updateBackground(self, instance, _):
self.background.pos = instance.pos
self.background.size = instance.size
def _updateGridRect(self, instance, _):
self.gridRect.pos = instance.pos
self.gridRect.size = instance.size
def _updateCoverRect(self, instance, _):
self.coverRect.pos = instance.pos
self.coverRect.size = instance.size
def _updateCalibOverlay(self, instance, _):
self.calibrationWidget.pos = instance.pos
self.calibrationWidget.size = instance.size
def build(self):
root = FloatLayout()
## Screen Manager
self.screen_manager = ScreenManager(transition=SlideTransition(),
size_hint=[None, None],
pos_hint={'left': 1})
root.bind(size=self.update_size)
root.add_widget(self.screen_manager)
## "Navbar" Buttons
## These are meant to work like the Android navbar would, and I have named them as such.
# These two functions are used for a indicator for the button being pressed.
def rend_circle(btn):
with btn.canvas:
Color(1, 1, 1, 0.25)
size = (btn.size[0], btn.size[1] * 1.5)
btn.hl = Ellipse(
pos=(btn.pos[0] + ((btn.size[0] / 2) - (size[0] / 2)),
btn.pos[1] + ((btn.size[1] / 2) - (size[1] / 2))),
size=size)
Color(1, 1, 1,
1) # Reset the color, otherwise the background goes dark
def derend_circle(btn):
btn.canvas.remove(btn.hl)
self.win_btn = Button(text='',
size_hint=[None, None],
size=[192, 192],
height=192,
pos_hint={
'right': 1,
'center_y': 0.8
})
self.win_btn.bind(on_press=rend_circle)
self.win_btn.bind(on_release=derend_circle)
self.win_btn.bind(on_release=self.pressed_win)
self.home_btn = Button(text='',
size_hint=[None, None],
size=[192, 192],
pos_hint={
'right': 1,
'center_y': 0.5
})
self.home_btn.bind(on_press=rend_circle)
self.home_btn.bind(on_release=derend_circle)
self.home_btn.bind(on_release=self.pressed_home)
self.back_btn = Button(text='',
size_hint=[None, None],
size=[192, 192],
pos_hint={
'right': 1,
'center_y': 0.2
})
self.back_btn.bind(on_press=rend_circle)
self.back_btn.bind(on_release=derend_circle)
self.back_btn.bind(on_release=self.pressed_back)
root.add_widget(self.win_btn)
root.add_widget(self.home_btn)
root.add_widget(self.back_btn)
# Render the background
def update_rect(instance, value):
instance.bg.pos = instance.pos
instance.bg.size = instance.size
self.screen_manager.bind(size=update_rect, pos=update_rect)
with self.screen_manager.canvas.before:
self.screen_manager.bg = Rectangle(source='background.png')
Loader.loading_image = 'loading.png'
## FileChooser
chooser_screen = Screen(name='chooser')
chooser = FileChooserGalleryView(rootpath=PHOTOS_PATH)
chooser.file_system = filesystem
def select_folder(chooser, photostrip):
photostrip.set_path(chooser.current_entry.path)
self.goto_screen('photostrip', 'left')
chooser.bind(
on_select_folder=lambda args: select_folder(chooser, photostrip))
chooser_screen.add_widget(chooser)
## Painter
self.paint_screen = PaintScreen(name='painter')
self.paint_screen.bind(
on_leave=lambda src: self.paint_screen.painter.clear())
## ImageViewer
viewer_screen = ViewerScreen(name='viewer')
viewer_screen.bind(on_enter=lambda src: setattr(
self.paint_screen.image, 'source', viewer_screen.image.source))
## Photo strip
def foo(a):
print type(a), a
photostrip_screen = Screen(name='photostrip')
photostrip = PhotoStrip()
photostrip_screen.add_widget(photostrip)
photostrip.bind(
on_press=lambda src, fn: viewer_screen.set_image(fn),
on_release=lambda src, fn: self.goto_screen('painter', 'left'),
)
# Set up the icons and functions for the navbar buttons
chooser_screen.btns = [None, 'ic_action_refresh.png', None]
chooser_screen.btn_functions = [None, chooser._trigger_update, None]
photostrip_screen.btns = [None, None, 'ic_sysbar_back.png']
photostrip_screen.btn_functions = [
None, None, lambda: self.goto_screen('chooser', 'right')
]
viewer_screen.btns = ['ic_action_edit.png', None, 'ic_sysbar_back.png']
viewer_screen.btn_functions = [
lambda: self.goto_screen('painter', 'left'),
viewer_screen.drawing_toggle,
lambda: self.goto_screen('photostrip', 'right')
]
self.paint_screen.btns = [
'ic_action_save.png', None, 'ic_action_discard.png'
]
self.paint_screen.btn_functions = [
self.save_painter, None,
lambda: self.goto_screen('photostrip', 'right')
]
# Finally, add the screens to the manager
self.screen_manager.add_widget(chooser_screen)
self.screen_manager.add_widget(photostrip_screen)
self.screen_manager.add_widget(viewer_screen)
self.screen_manager.add_widget(self.paint_screen)
# Set the navbar buttons from the variables set above
self.screen_manager.transition.bind(on_complete=self.update_buttons)
self.update_buttons()
return root
class GeniusPad(App):
def build(self):
self.dir_path = os.path.dirname(os.path.realpath(__file__))
Window.clearcolor = (1, 1, 1, 1)
self.parent = FloatLayout(size=(300, 300))
self.painter = ClipBoard()
clearbtn = Button(text='Clear',
size_hint=(.1, .1),
pos_hint={
'x': .0,
'y': .0
})
self.savebtn = Button(text="Compute",
size_hint=(.1, .1),
pos_hint={
'x': .9,
'y': .0
})
clearbtn.bind(on_release=self.clear_canvas)
self.savebtn.bind(on_release=self.init_compute)
self.parent.add_widget(self.painter)
self.parent.add_widget(clearbtn)
self.parent.add_widget(self.savebtn)
self.parent.bind(size=self._update_rect, pos=self._update_rect)
self.img_count = 0
self.pipe = mp.Queue()
self.cluster_boxes = None
with self.parent.canvas.before:
Color(1, 1, 1, 1)
self.rect = Rectangle(size=self.parent.size, pos=self.parent.pos)
return self.parent
def init_compute(self, _):
self.computation_start = time.time()
# remove bounding boxes
if self.cluster_boxes is not None:
self.painter.canvas.remove(self.cluster_boxes)
img_array = self.generate_image_data()
self.task = mp.Process(target=EquationRecognizer,
args=(img_array, self.pipe))
self.task.start()
# fetch the result after one second
Clock.schedule_once(self.fetch_compute_result, .1)
def fetch_compute_result(self, dt):
if self.task.is_alive():
Clock.schedule_once(self.fetch_compute_result, .1)
else:
self.render_with_result()
def render_with_result(self):
try:
result = self.pipe.get(timeout=1)
except queue.Empty:
pr_info("Something went wrong with the computation", mode="W")
return
pr_info("Computation Result:", result.info)
self.cluster_boxes = InstructionGroup()
self.cluster_boxes.add(Color(0, 0, 0, 1))
for info in result.data:
pr_info("Rectangle: ", info[0], info[1], info[2], info[3])
self.cluster_boxes.add(
Line(points=(info[3], self.painter.height - info[0], info[2],
self.painter.height - info[0], info[2],
self.painter.height - info[1], info[3],
self.painter.height - info[1], info[3],
self.painter.height - info[0])))
self.painter.canvas.add(self.cluster_boxes)
pr_info("Computation took {:.3f}s".format(time.time() -
self.computation_start))
def _update_rect(self, instance, value):
self.rect.pos = instance.pos
self.rect.size = instance.size
def clear_canvas(self, obj):
self.painter.canvas.clear()
def generate_image_data(self):
fbo = self.painter.make_fbo()
with self.parent.canvas:
anmi = Animation(opacity=0, duration=3)
x, y = Window.size
label_size = x / 2, y / 2
msg = Label(text="Computing...",
color=[0, 0, 0, 1],
size=label_size,
texture_size=label_size,
bold=True)
anmi.start(msg)
# each pixel is 8 bits, but the idea of color needs to be abstracted out
image_array = np.frombuffer(fbo.pixels, dtype=np.uint32)
has_drawing = image_array > 0
# get rid of the unnecessary value, clone the only knowledge we need
processed_array = np.zeros(shape=image_array.shape, dtype=np.uint8)
processed_array[has_drawing] = 1
# recover the shape, took me one hour to find this out
processed_array.shape = (fbo.size[1], fbo.size[0])
#np.save("./plus"+str(randint(0,99999)), processed_array)
return processed_array
class Viewer(Screen):
def __init__(self,**kwargs):
super (Viewer,self).__init__(**kwargs)
self.master=FloatLayout()
Window.clearcolor=(0,1,0,5)
self.addb=Button(text="ADD",pos=(WXY(2),HXY(450)),width=WXY(60),height=HXY(30),size_hint=(None,None),font_size=HXY(16))
self.addb.bind(on_press=self.adder)
self.master.add_widget(self.addb)
self.layout = GridLayout(cols=1, spacing=HXY(4), size_hint_y=None)
self.layout.bind(minimum_height=self.layout.setter('height'))
self.connection=Connection()
self.values=self.connection.getvalues("date,content","diarydata")
self.lists=[]
index=0
for date,content in self.values:
self.lists.append(Button(text=content[:int(WXY(20))]+"-----"+str(date), size_hint_y=None, height=30,font_size=18,halign="left", valign="middle"))
self.lists[index].bind(size=self.lists[index].setter('text_size'))
self.lists[index].bind(on_press=self.popuptriger)
self.layout.add_widget(self.lists[index])
index+=1
self.connection.conn.close();
self.root = ScrollView(size=(WXY(310),HXY(440)),pos=(WXY(5),HXY(0)),size_hint=(None,None))
self.root.add_widget(self.layout)
self.master.add_widget(self.root)
self.master.bind(size=self.on_rotate)
self.add_widget(self.master)
def on_rotate(self,event,event1):
global screenheight
global screenwidth
global choice
screenheight=Window.height
screenwidth=Window.width
self.addb.pos=(WXY(2),HXY(450))
self.addb.width=WXY(60)
self.addb.height=HXY(30)
self.addb.font_size=HXY(16)
self.root.size=(WXY(310),HXY(440))
self.root.pos=(WXY(5),HXY(0))
self.layout.spacing=HXY(4)
index=0
def popuptriger(self,event):
editButton = Button(text = "Edit")
deleteButton = Button(text = "Delete")
cancelButton = Button(text = "Cancel")
self.identity=event.text
layout = BoxLayout()
self.userpriority=Popup(title="Do you wish to continue",content=layout,width=Window.width,height=HXY(100),size_hint=(None,None))
layout.add_widget(deleteButton)
layout.add_widget(editButton)
layout.add_widget(cancelButton)
editButton.bind(on_press=self.deletelists)
deleteButton.bind(on_press=self.editviewer)
cancelButton.bind(on_press=self.userpriority.dismiss)
self.userpriority.open()
def deletelists(self,event):
pass
def editviewer(self,event):
pass
def adder(self,event):
self.master.remove_widget(self.addb)
self.master.remove_widget(self.root)
self.manager.current="Logger"
def build(self):
root = FloatLayout()
## Screen Manager
self.screen_manager = ScreenManager(transition=SlideTransition(),size_hint=[None,None], pos_hint={'left': 1})
root.bind(size=self.update_size)
root.add_widget(self.screen_manager)
## "Navbar" Buttons
## These are meant to work like the Android navbar would, and I have named them as such.
# These two functions are used for a indicator for the button being pressed.
def rend_circle(btn):
with btn.canvas:
Color(1,1,1,0.25)
size = (btn.size[0], btn.size[1]*1.5)
btn.hl = Ellipse(pos=( btn.pos[0]+((btn.size[0]/2)-(size[0]/2)), btn.pos[1]+((btn.size[1]/2)-(size[1]/2)) ), size=size)
Color(1,1,1,1) # Reset the color, otherwise the background goes dark
def derend_circle(btn):
btn.canvas.remove(btn.hl)
self.win_btn = Button(text='', size_hint=[None,None],size=[192,192],height=192,pos_hint={'right': 1, 'center_y': 0.8})
self.win_btn.bind(on_press=rend_circle)
self.win_btn.bind(on_release=derend_circle)
self.win_btn.bind(on_release=self.pressed_win)
self.home_btn = Button(text='', size_hint=[None,None],size=[192,192],pos_hint={'right': 1, 'center_y': 0.5})
self.home_btn.bind(on_press=rend_circle)
self.home_btn.bind(on_release=derend_circle)
self.home_btn.bind(on_release=self.pressed_home)
self.back_btn = Button(text='', size_hint=[None,None],size=[192,192],pos_hint={'right': 1, 'center_y': 0.2})
self.back_btn.bind(on_press=rend_circle)
self.back_btn.bind(on_release=derend_circle)
self.back_btn.bind(on_release=self.pressed_back)
root.add_widget(self.win_btn)
root.add_widget(self.home_btn)
root.add_widget(self.back_btn)
# Render the background
def update_rect(instance, value):
instance.bg.pos = instance.pos
instance.bg.size = instance.size
self.screen_manager.bind(size=update_rect,pos=update_rect)
with self.screen_manager.canvas.before:
self.screen_manager.bg = Rectangle(source='background.png')
Loader.loading_image = 'loading.png'
## FileChooser
chooser_screen = Screen(name='chooser')
chooser = FileChooserGalleryView(rootpath=PHOTOS_PATH)
chooser.file_system = filesystem
def select_folder(chooser, photostrip):
photostrip.set_path(chooser.current_entry.path)
self.goto_screen('photostrip', 'left')
chooser.bind(on_select_folder=lambda args:select_folder(chooser, photostrip))
chooser_screen.add_widget(chooser)
## Painter
self.paint_screen = PaintScreen(name='painter')
self.paint_screen.bind(on_leave=lambda src: self.paint_screen.painter.clear())
## ImageViewer
viewer_screen = ViewerScreen(name='viewer')
viewer_screen.bind(on_enter=lambda src:setattr(self.paint_screen.image,'source',viewer_screen.image.source))
## Photo strip
def foo(a):
print type(a), a
photostrip_screen = Screen(name='photostrip')
photostrip = PhotoStrip()
photostrip_screen.add_widget(photostrip)
photostrip.bind(
on_press=lambda src,fn:viewer_screen.set_image(fn),
on_release=lambda src,fn: self.goto_screen('painter', 'left'),
)
# Set up the icons and functions for the navbar buttons
chooser_screen.btns = [None, 'ic_action_refresh.png', None]
chooser_screen.btn_functions = [None, chooser._trigger_update, None]
photostrip_screen.btns = [None, None, 'ic_sysbar_back.png']
photostrip_screen.btn_functions = [None, None, lambda:self.goto_screen('chooser', 'right')]
viewer_screen.btns = ['ic_action_edit.png', None, 'ic_sysbar_back.png']
viewer_screen.btn_functions = [lambda:self.goto_screen('painter', 'left'), viewer_screen.drawing_toggle, lambda:self.goto_screen('photostrip', 'right')]
self.paint_screen.btns = ['ic_action_save.png', None, 'ic_action_discard.png']
self.paint_screen.btn_functions = [self.save_painter, None, lambda:self.goto_screen('photostrip', 'right')]
# Finally, add the screens to the manager
self.screen_manager.add_widget(chooser_screen)
self.screen_manager.add_widget(photostrip_screen)
self.screen_manager.add_widget(viewer_screen)
self.screen_manager.add_widget(self.paint_screen)
# Set the navbar buttons from the variables set above
self.screen_manager.transition.bind(on_complete=self.update_buttons)
self.update_buttons()
return root
class Notepad(Screen):
def __init__(self,**kwargs):
super (Notepad,self).__init__(**kwargs)
self.master=FloatLayout()
self.datesetter=TextInput(text=str(today.today()),pos=(WXY(5),HXY(440)),width=WXY(146),height=HXY(40),font_size=HXY(25),size_hint=(None,None))
self.submit=Button(text="submit",pos=(WXY(174),HXY(440)),width=WXY(141),height=HXY(40),size_hint=(None,None),font_size=HXY(25))
self.submit.bind(on_press=self.popuptriger)
self.content=TextInput(text="share your thoughts on today",pos=(WXY(5),HXY(5)),width=WXY(310),height=HXY(430),font_size=(HXY(18)),size_hint=(None,None))
self.master.add_widget(self.datesetter)
self.master.add_widget(self.submit)
self.master.add_widget(self.content)
self.master.bind(size=self.on_rotate)
Window.clearcolor=(0,1,0,5)
self.add_widget(self.master)
def on_rotate(self,event,event1):
global screenheight
global screenwidth
screenheight=Window.height
screenwidth=Window.width
self.datesetter.pos=(WXY(5),HXY(440))
self.datesetter.width=WXY(146)
self.datesetter.height=HXY(40)
self.datesetter.font_size=HXY(25)
self.submit.pos=(WXY(174),HXY(440))
self.submit.width=WXY(141)
self.submit.height=HXY(40)
self.submit.font_size=HXY(25)
self.content.pos=(WXY(5),HXY(5))
self.content.width=WXY(310)
self.content.height=HXY(430)
self.content.font_size=HXY(18)
def popuptriger(self,event):
closeButton = Button(text = "Close")
cancelButton = Button(text = "cancel")
saveButton = Button(text = "Save")
layout = BoxLayout()
self.userpriority=Popup(title="Do you wish to continue",content=layout,width=Window.width,height=HXY(100),size_hint=(None,None))
layout.add_widget(cancelButton)
layout.add_widget(saveButton)
layout.add_widget(closeButton)
saveButton.bind(on_press=self.saveswapper)
closeButton.bind(on_press=self.nonsaveswapper)
cancelButton.bind(on_press=self.userpriority.dismiss)
self.userpriority.open()
def saveswapper(self,event):
res=0;
for i in self.datesetter.text:
if(i>='0' and i<'9'):
res=(res*10)+int(i)
self.connection=Connection()
values="({},'{}')".format(res,str(self.content.text))
columnname="('{}','{}')".format("date","content")
self.connection.insertintotable("diarydata",columnname,values)
self.connection.conn.close()
self.removelayout()
def nonsaveswapper(self,event):
self.userpriority.dismiss()
self.set_previous_screen()
def removelayout(self):
self.userpriority.dismiss()
self.master.remove_widget(self.datesetter)
self.master.remove_widget(self.content)
self.master.remove_widget(self.submit)
class Application(App):
def build(self):
Window.clearcolor = (1, 1, 1, 0)
#Window.size=(320,480)
self.connection = Connection()
self.img = Image(source='net.jpeg', size_hint=(None, None))
self.img.allow_stretch = True
self.img.opacity = 1
self.password = TextInput(text="password",
multiline=False,
size_hint=(None, None))
self.loginbutton = Button(text="Unlock", size_hint=(None, None))
self.loginbutton.bind(on_press=self.login)
self.registerbutton = Button(text="Register", size_hint=(None, None))
self.registerbutton.bind(on_press=self.register)
#creating layout based on conditions
cols = self.connection.size("pwmanager")
self.master = FloatLayout()
if cols is not 1:
self.master.add_widget(self.registerbutton)
else:
self.master.add_widget(self.loginbutton)
self.master.add_widget(self.img)
self.master.add_widget(self.password)
self.master.bind(size=self.on_rotate)
return self.master
def login(self, event):
passwordtext = self.connection.getvalues("*", "pwmanager")
userentry = ""
for i in passwordtext.fetchone():
userentry = i
if (userentry == self.password.text):
self.master.remove_widget(self.loginbutton)
self.master.remove_widget(self.img)
self.master.remove_widget(self.password)
self.connection.conn.close()
self.viewer = Viewer(self.master)
else:
self.password.text = "Retry"
global choice
choice = 2
def register(self, event):
if (self.password.text is not ""):
values = "('{}')".format(str(self.password.text))
columnname = "('{}')".format("password")
self.connection.insertintotable("pwmanager", columnname, values)
self.master.remove_widget(self.registerbutton)
self.master.add_widget(self.loginbutton)
self.password.text = ""
def on_rotate(self, event, event1):
global screenheight
global screenwidth
global choice
screenheight = Window.height
screenwidth = Window.width
if (choice == 1):
self.img.pos = (WXY(60), HXY(263))
self.img.width = WXY(207)
self.img.height = HXY(164)
self.password.pos = (WXY(53), HXY(180))
self.password.width = WXY(208)
self.password.height = HXY(37)
self.password.font_size = HXY(18)
self.loginbutton.pos = (WXY(82), HXY(117))
self.loginbutton.width = WXY(146)
self.loginbutton.height = HXY(40)
self.loginbutton.font_size = HXY(18)
self.registerbutton.pos = (WXY(82), HXY(117))
self.registerbutton.width = WXY(146)
self.registerbutton.height = HXY(40)
elif (choice == 2):
self.viewer.on_rotate()
elif (choice == 3):
self.viewer.notepad.on_rotate()
class EuclidApp(App):
# BUILD
def build(self):
self.root = FloatLayout()
self.root.bind(size = self._update_rect,
pos = self._update_rect)
with self.root.canvas.before:
Color(1, 1, 1, 1)
self.rect = Rectangle(size = self.root.size,
pos = self.root.pos)
bg = Image(source = 'ec_logo.png')
self.txt_in = CapitalInput(
text = '',
multiline = False,
font_size = 30,
size_hint=(0.95, 0.07),
pos_hint = {'center_x': 0.5, 'center_y': 0.9}
)
grid = GridLayout(
cols = 1,
padding = 2,
spacing = 5,
size_hint = (1, None),
)
grid.bind(minimum_height = grid.setter('height'))
# ADD A BUTTON TO INSTANCE
def add_button(instance, value):
btn = Button(
text = value,
size_hint = (1, None),
font_size = 30,
background_color = (0.4, 0.2, 0.6, 0.9),
background_normal = ''
)
output = values[value]
btn.bind(on_press = partial(self.buttonHandler, grid, output))
instance.add_widget(btn)
# DEFINE BEHAVIOUR FOR TEXT INPUT
def on_text(instance, value):
grid.clear_widgets()
a_list = dict_lookup(values, str(value))
if len(value) > 0:
for i in range(len(a_list)):
add_button(grid, a_list[i])
self.txt_in.bind(text = on_text)
scroll = ScrollView(
size_hint = (0.95, 0.8),
pos_hint = {'center_x': .5, 'center_y': .4},
do_scroll_x = False
)
scroll.add_widget(grid)
self.root.add_widget(bg)
self.root.add_widget(self.txt_in)
self.root.add_widget(scroll)
return self.root
# UPDATE BACKGROUND COLOUR
def _update_rect(self, instance, value):
self.rect.pos = instance.pos
self.rect.size = instance.size
# BUTTON HANDLER
def buttonHandler(self, grid, value, button):
grid.clear_widgets()
btn = Button(
text = value,
size = (0, 500),
size_hint = (1, None),
font_size = 30,
background_color = (0.6, 0.2, 0.4, 0.9),
background_normal = '',
background_down = ''
)
grid.add_widget(btn)
def ErrorWindow(self):
popupwindow = FloatLayout()
# add events to the widgets
def port_on_release(self):
self.popup_label.text = f'Configure to port: {self.port.text} .' if (
self.baudrate.text == 'Baudrate'
) else f'Configure to port: {self.port.text} and baudtare: {self.baudrate.text} .'
def baudrate_on_release(self):
self.popup_label.text = f'Configure to port: {self.port.text} .' if (
self.baudrate.text == 'Baudrate'
) else f'Configure to port: {self.port.text} and baudtare: {self.baudrate.text} .'
def try_on_press(self):
print('try_on_press')
def close_on_press(self):
print('close_on_press')
# define popup window widgets
self.port = Spinner(text='Port',
values=AccordionApp.PORTS,
pos_hint={
'x': 0.0,
'center_y': 0.8
},
size_hint=[0.5, 0.1],
on_text=lambda spinner: port_on_release(self))
self.baudrate = Spinner(
text='Baudrate',
values=AccordionApp.BAUDRATES,
pos_hint={
'x': 0.5,
'center_y': 0.8
},
size_hint=[0.5, 0.1],
on_release=lambda spinner: baudrate_on_release(self))
self.popup_label = Label(
text='please choose port and baudrate to configure correctly.',
pos_hint={
'center_x': 0.3,
'center_y': 0.5
},
size_hint=[0.8, 0.1])
self.popup_try = Button(text='try',
pos_hint={
'x': 0,
'y': 0
},
size_hint=[0.5, 0.1],
on_press=lambda button: try_on_press(self))
self.popup_close = Button(text='close',
pos_hint={
'x': 0.5,
'y': 0
},
size_hint=[0.5, 0.1],
on_press=lambda button: close_on_press(self))
# add modules to the popup window
popupwindow.add_widget(self.popup_label)
popupwindow.add_widget(self.popup_try)
popupwindow.add_widget(self.popup_close)
popupwindow.add_widget(self.port)
popupwindow.add_widget(self.baudrate)
# make popup window
popup = Popup(content=popupwindow,
title='Configuration',
auto_dismiss=False)
# bind the on_press event of the button to the dismiss function
popupwindow.bind(on_press=popup.dismiss)
popup.open()
class song_page(FloatLayout):
def __init__(self, music_app_self, **kwargs):
super(song_page, self).__init__(**kwargs)
global other_layout, len_btn, len_btn2, song_page_self
global curr_song, pre_song, pre_sound, song_counter, bt2, bt1, bt3
global len_slid, sh, val_pre
########################################################################
song_page_self = self
# self.song_page_box = BoxLayout(orientation = 'vertical')
# tool_box.size_hint = (self.size_hint[0]*0.2,self.size_hint[1]*0.2)
# self.song_page_box.pos = (0,540)
self.tb = my_MDToolbar(title='song name',
anchor_title='center',
background_palette='Primary')
self.tb.md_bg_color = [1, 1, 1, 0.3]
self.tb.pos_hint = {'x': 0, 'y': 0.9}
self.tb.left_action_items = [[
'chevron-down', lambda x: self.gonext(music_app_self)
]]
# self.song_page_box.add_widget(self.tb)
self.add_widget(self.tb)
self.song_page_float = FloatLayout(size=(100, 100))
############################################################
with self.song_page_float.canvas.after:
self.song_page_float.rect = RoundedRectangle(segments=15,
radius=[50])
self.song_page_float.rect.source = 'images/image_2.jpg'
def update_rect(instance, value):
instance.rect.size = [
instance.size[0] * 0.8, instance.size[0] * 0.6
]
instance.rect.pos = [
instance.pos[0] + instance.size[0] * 0.1,
instance.pos[1] + instance.size[1] * 0.4
]
self.song_page_float.bind(pos=update_rect, size=update_rect)
###########################################################
# self.im1 = Image(source='images/image_2.jpg', color=(1,1,1,.5),
# size_hint=(self.size_hint[0]*0.3,self.size_hint[1]*0.3))
#
# self.im1.pos_hint={'x':.35, 'y':.4}
#
# self.song_page_float.add_widget(self.im1)
#
self.add_widget(self.song_page_float)
#########################################################
self.grid_2 = GridLayout(cols=3,
size_hint=(1, 0.2),
row_force_default=True,
row_default_height=40,
opacity=1)
# print(self.grid_2.size_hint)
self.b1 = Label(text='00:00',
color=(0, 0, 1, 0.5),
size_hint_x=None,
width=self.width)
self.grid_2.add_widget(self.b1)
self.slid = Slider(min=-1,
max=100,
value=0,
cursor_width='8dp',
cursor_height='30dp',
value_track=True,
background_width='8dp',
value_track_width='1.5dp',
value_track_color=[0, 0, 1, 1],
step=1)
self.slid.pos = (1, 100)
self.grid_2.add_widget(self.slid)
self.b2 = Label(text='min' + ':' + 'sec',
size_hint_x=None,
width=self.width,
color=(0, 0, 1, 0.5))
self.grid_2.add_widget(self.b2)
len_btn = self.b2
len_btn2 = self.b1
len_slid = self.slid
self.slid.bind(value=slid_bind)
self.add_widget(self.grid_2)
fl = FloatLayout(size_hint=(1, 0.05), opacity=1)
bt1 = ImgButton_pre(prev_normal_img, prev_press_img, id='pre')
# bt1.bind(on_press = partial(self.previous_song))
fl.add_widget(bt1)
bt2 = ImgToggleButton_play(play_img, pause_img, id='pp')
# bt2.bind(on_press = partial(self.play_pause))
fl.add_widget(bt2)
bt3 = ImgButton_next(next_normal_img, next_press_img, id='next')
# bt3.bind(on_press = partial(self.next_song))
fl.add_widget(bt3)
self.add_widget(fl)
# self.add_widget(self.song_page_box)
def gonext(self, music_app_self):
music_app_self.sm.transition.direction = 'down'
music_app_self.sm.current = 'mainscreen'
def update_info(btn_self, index, main_self, music_app_self, *args):
global song_page_self, co, pre_sound, bt2, ite, pre_song, bt1, bt3, sh, len_btn2, len_slid
global cpb, ite, my_fb
# def animate(self,dt, song_len):
# print(self)
# print(dt)
# print(song_len)
# bar = self.children[0]
# if bar.value < bar.max:
# bar.value_normalized += 1/(self.children[0]._max_progress)
curr_song = index
file = File(songlist[index][0])
song_length = float(file.info.pprint().split(',')[-1:][0][:-8])
time = song_length / 60
minute = int(time)
min_str = "{0:0=2d}".format(minute)
second = int(round((time - minute) * 60, 2))
sec_str = "{0:0=2d}".format(second)
try:
singer = file['TPE1'].text[0]
except:
try:
singer = file['TALB'].text[0]
except:
singer = ''
try:
song_name = file['TIT2'].text[0]
except:
song_name = (file.filename.split('/'))[-1:][0]
song_page_self.tb.title = '[b]' + song_name + '[/b]'
song_page_self.tb.ids['lbl2'].text = singer
song_page_self.b2.text = min_str + ':' + sec_str
song_page_self.slid.max = int(song_length)
# song_page_self.im1.source = cover_album[index]
song_page_self.song_page_float.rect.source = cover_album[index]
# ########################################################
if (co == 0):
my_fb = FloatLayout()
my_fb.size_hint = [1, 0.09]
# ############################################3
ite = ItemMenuForFitness()
ite.bt_img(my_fb)
ite.bind(on_release=partial(song_page_self.gonext_playpage,
music_app_self))
############################################3
cpb = CircularProgressBar(ite)
cpb.size_hint = ite.size_hint
my_fb.add_widget(cpb)
#############################################
co += 1
main_self.add_widget(my_fb)
##################################################
bt1.bind(on_press=partial(song_page_self.previous_song, btn_self,
main_self, music_app_self))
bt2.bind(on_press=partial(song_page_self.play_pause, btn_self))
bt3.bind(on_press=partial(song_page_self.next_song, btn_self,
main_self, music_app_self))
################################################
ite.rect4.source = cover_album[index]
cpb._max_progress = int(song_length)
# try:
# csh.cancel()
# except:
# pass
# csh = Clock.schedule_interval(partial(animate, my_fb, (song_length)), 1)
# ########################################################
#####################################################################
## play song
try:
bt2.state = 'down'
ImgToggleButton_play.on_state(bt2, 'fwfwf', 'normal')
pre_sound.stop()
pre_sound.unload()
pre_song = -1
except:
pre_song = -1
if (curr_song != pre_song):
if (btn_self.state == 'down'):
bt2.state = 'down'
ImgToggleButton_play.on_state(bt2, 'fwfwf', 'down')
sound = SoundLoader.load(songlist[index][0])
if (sound != None):
val_pre = -1
sh = slid_func(sound, len_slid, len_btn2, my_fb,
song_page_self)
sound.play()
pre_sound = sound
pre_song = index
song_counter = index
songlist[pre_song][1].state = 'down'
######################################################################
def gonext_playpage(self, music_app_self, bke):
music_app_self.sm.transition.direction = 'up'
music_app_self.sm.current = "playpage"
def play_pause(self, whjfvwh, btn_self):
global curr_song, pre_song, pre_sound, song_counter, len_slid, len_btn2, sh, song_position
global my_fb
if (btn_self.state == 'normal'):
try:
song_position = pre_sound.get_pos()
sh.cancel()
pre_sound.stop()
pre_sound.unload()
songlist[pre_song][1].state = 'normal'
print(songlist[pre_song][0] + ' : stoped')
except:
pass
else:
index = pre_song
sound = SoundLoader.load(songlist[index][0])
bt2.state = 'down'
ImgToggleButton_play.on_state(bt2, 'fwfwf', 'down')
if (sound != None):
val_pre = -1
sound.play()
sound.seek(song_position)
sh = slid_func(sound, len_slid, len_btn2, my_fb,
song_page_self)
pre_song = index
song_counter = index
pre_sound = sound
songlist[pre_song][1].state = 'down'
print(songlist[pre_song][0] + ' : playing')
def previous_song(self, amdvh, btn_self, main_self, music_app_self):
global curr_song, pre_song, pre_sound, song_counter, up_btn_self, up_main_self, up_music_app_self
pre_sound.stop()
pre_sound.unload()
songlist[song_counter][1].state = 'normal'
song_counter = song_counter - 1
if (song_counter < 0):
song_counter = 0
song_page.update_info(music_app_self, song_counter, main_self,
btn_self)
def next_song(self, ahvdhj, btn_self, main_self, music_app_self):
global curr_song, pre_song, pre_sound, song_counter, up_btn_self, up_main_self, up_music_app_self
pre_sound.stop()
pre_sound.unload()
songlist[song_counter][1].state = 'normal'
song_counter = song_counter + 1
if (song_counter == len(songlist)):
song_counter = len(songlist) - 1
song_page.update_info(music_app_self, song_counter, main_self,
btn_self)
