def __init__(self, capteur, titre="", **kvargs):
super().__init__(**kvargs)
self.g = []
self.titre = titre
self.L = 300
self.H = 200
self.graphX = []
self.graphY = []
self.y_mid = self.H / 2
self.capteur = capteur
self.label_titre = Label(text=self.titre,
color=(1, 0.5, 0),
text_size=(self.width, self.height),
size_hint=(1, 2),
padding_y=0)
self.add_widget(self.label_titre)
Clock.schedule_interval(self.update, FREQ)
self.temps = 0
pas = int(300/10*FREQ)
# pas = 3
max_graph = int(10/FREQ)
# max_graph = 90
if self.capteur.nom == "Altitude":
for i in range(0, max_graph):
self.graphX.append(pas*i)
self.graphY.append(0)
else:
for i in range(0, max_graph):
self.graphX.append(pas*i)
# pas*i = 89*3 =
self.graphY.append(self.y_mid)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.rw = RootWidget(gameStatus='Not Completed')
self.add_widget(self.rw)
# call update() every second
#Clock.schedule_interval(self.rw.update, 1.0)
Clock.schedule_interval(self.update, 1.0)
def buttonPlay(self):
"""再生ボタンクリック時"""
try:
if not Holder.getStatus() == "" and not Holder.getStatus(
) == "play":
# 再生中でなければ
try:
pygame.mixer.music.play(0, Holder.getSlideValue())
Clock.schedule_interval(self.position, 0.1)
self.image_play = "image/pause.png"
# self.sound_vlc.play()
# self.sound_vlc.set_time(int(Holder.getSlideValue() * 1000))
Holder.setStatus("play")
except:
pass
else:
Holder.setSlideValue(self.ids.slider.value)
pygame.mixer.music.pause()
self.image_play = "image/play.png"
# self.sound_vlc.pause()
Clock.unschedule(self.position)
Holder.setStatus("pause")
except:
pass
def __init__(self, **kwargs):
super(MainWidget, self).__init__(**kwargs)
# print(f"INIT W = {self.width} // H = {self.height}")
self.init_vertical_lines()
self.init_horizontal_lines()
self.current_offset_y = 0
self.current_offset_x = 0
self.current_speed_x = 0
self.current_y_loop = 0
self.init_audio()
self.state_game_started = False
self.state_game_over = False
self.init_tiles()
self.init_ship()
self.pre_fill_tiles_coordinates()
self.generate_tiles_coordinates()
if is_desktop():
self._keyboard = Window.request_keyboard(self._keyboard_closed,
self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
self._keyboard.bind(on_key_up=self._on_keyboard_up)
Clock.schedule_interval(self.update, 1.0 / 60.)
self.sound_galaxy.play()
def init_game(self, mode):
game = Game()
controller = Controller(game)
ai = AI(game)
first_player = Player(PieceColor.WHITE, controller,
ai if mode == GameMode.AI_VS_HUMAN else None)
second_player = Player(PieceColor.BLACK, controller,
ai if mode == GameMode.HUMAN_VS_AI else None)
players = [first_player, second_player]
game_board = GameBoardWidget(game)
for player in players:
if player.type == PlayerType.HUMAN:
game_board.move_receive_from_ui.append(
player.move_receive_from_ui_handler)
if first_player.type == PlayerType.AI:
first_player.move_complete_event(PieceColor.BLACK)
Clock.schedule_interval(lambda delta_time: game_board.update(), 0.03)
self.clear_widgets()
game_widget = GameWidget(game)
size = (game_board.width, game_board.height + 50)
game_widget.size = size
Window.size = size
game_widget.set_game_board(game_board)
self.add_widget(game_widget)
def __init__(self, nom=""):
try:
self.ser = serial.Serial('/dev/cu.usbmodem1411', 9600)
except:
print("no reception")
self.nom = nom
self.data = .0
Clock.schedule_interval(self.recepteur_update, FREQ)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.ball_size = dp(50)
self.vx = dp(10)
self.vy = dp(10)
with self.canvas:
self.ball = Ellipse(pos=(100, 100), size=(self.ball_size, self.ball_size))
Clock.schedule_interval(self.update, 1/60)
def __init__(self, recepteur, **kwargs):
super().__init__(**kwargs)
Clock.schedule_interval(self.update_controle_tir, .1)
self.launch_time = None
self.date_since_launch = None
self.recepteur = recepteur
self.feu_reception = RelativeLayout()
self.feu_reception.add_widget(Label(text="Reception:"))
self.add_widget(self.feu_reception)
def build(self):
self.plot.points = [(point[0], point[1]) for point in
self.user.userECG.ecgListFFT]
# self.plot.points = [(x, sin(x / 100.)) for x in range(self.counter,
# self.counter + 10)]
self.graph.add_plot(self.plot)
Clock.schedule_interval(self.update, 1.0 / 60.0)
return self.graph
def start_reading(self):
self.reading_running = True
self.text_position_progress = 0
text_left = self.text_db[self.text_position:]
self.text_iterator = iter(text_left)
self.get_next_word_event = Clock.schedule_interval(
self.get_next_word,
1.0 / (int(self.preferences_data['reading_speed']) / 60))
self.update_status_event = Clock.schedule_interval(
self.update_status, 1.0)
def build(self):
self.plot.points = [(point[0], point[1]) for point in
self.eog.gesture_list]
# self.plot.points = [(x, sin(x / 100.)) for x in range(self.counter,
# self.counter + 10)]
self.graph.add_plot(self.plot)
Clock.schedule_interval(self.update, 1.0 / 60.0)
return self.graph
def build(self):
# Create the screen manager
sm = ScreenManager()
game = CarGame()
screen = Screen(name="game")
screen.add_widget(game)
Clock.schedule_interval(game.update, 1.0 / 1000.0)
Clock.schedule_interval(game.addObstacle, 1.0 / 1.7)
sm.add_widget(StartScreen(name="start"))
sm.add_widget(screen)
return sm
def __init__(self, nom=""):
self.nom = nom
self.data = .0
self.is_connected = False
try:
self.ser = serial.Serial('/dev/cu.usbmodem1411', 9600)
self.is_connected = True
except:
print("no reception")
self.is_connected = False
Clock.schedule_interval(self.recepteur_update, FREQ)
def __init__(self, ctrl_tir, **kwargs):
super().__init__(**kwargs)
self.ctrl_tir = ctrl_tir
self.angles = []
self.phases = []
Clock.schedule_interval(self.update, FREQ)
"""Paramètres de la mission par une fenetre de parametres"""
self.set_mission()
self.draw_X()
self.affiche_timer("T+00:00:00", 26, 430, 30)
def __init__(self, **kwargs):
super(MainWidget, self).__init__(**kwargs)
# print("INIT W:" + str(self.width) + " H:" + str(self.height))
self.init_vertical_lines()
self.init_horizontal_lines()
if self.is_desktop():
self._keyboard = Window.request_keyboard(self.keyboard_closed,
self)
self._keyboard.bind(on_key_down=self.on_keyboard_down)
self._keyboard.bind(on_key_up=self.on_keyboard_up)
Clock.schedule_interval(self.update, 1.0 / 60.0)
def __init__(self, **kw):
super().__init__(**kw)
self.playlist = StaticPlaylist([])
self.__cached_playlist = list(self.playlist)
self.load_audio()
def update_position(_):
if self.sound and self.sound.state == 'play':
self.last_sound_position = self.sound.get_pos()
Clock.schedule_interval(update_position, 1.5)
def start_app(self, *args):
self.add_widget(ErrorScreen())
self.add_widget(FreeRoomScreen())
self.add_widget(OkCancelModalScreen())
self.add_widget(CalendarScreen())
self.add_widget(StatusScreen())
self.add_widget(EditMeetingScreen())
self.add_widget(MeetingDetailsScreen())
self.check_meetings()
self.go_to_main_screen()
Clock.schedule_interval(self.check_meetings, 5)
def __init__(self, **kwargs):
super(NewsWidget, self).__init__(**kwargs)
self.app = App.get_running_app()
app_config = self.app.config
provider = app_config.get('news', 'provider')
news_module = imp.load_source(provider, os.path.join(PROJECT_PATH, 'libs', "news", "%s.py" % provider))
self.news_provider = news_module.News()
Clock.schedule_interval(self.update_news, 600)
Clock.schedule_interval(self.rotate_news, app_config.getint('news', 'cycle_interval'))
self.update_news()
self.key_handler = self.app.key_handler
self.key_handler.bind('down', lambda *args: self.rotate_news(direction='next', manual=True))
self.key_handler.bind('up', lambda *args: self.rotate_news(direction='prev', manual=True))
def on_start(self):
ble_central.init()
ble_peripheral.init()
ble_central.set_callbacks(on_state=self.central_state_changed,
on_discover=self.discover)
ble_peripheral.set_callbacks(on_state=self.peripheral_state_changed,
on_service_added=self.peripheral_service_added,
on_service_error=self.peripheral_service_error,
on_advertising_started=self.peripheral_adv,
on_advertising_error=self.peripheral_adv,
on_characteristic_subscribed=self.char_sub,
on_characteristic_write=self.char_write)
self.scanning = ble_central.is_scanning
Clock.schedule_interval(self.update_list, 0.5)
def __init__(self, **kw):
super().__init__(**kw)
self.playlist = StaticPlaylist([
])
self.__cached_playlist = list(self.playlist)
self.load_audio()
def update_position(_):
if self.sound and self.sound.state == 'play':
self.last_sound_position = self.sound.get_pos()
Clock.schedule_interval(update_position, 1.5)
def on_start(self):
ble_central.init()
ble_peripheral.init()
ble_central.set_callbacks(on_state=self.central_state_changed,
on_discover=self.discover)
ble_peripheral.set_callbacks(on_state=self.peripheral_state_changed,
on_service_added=self.peripheral_service_added,
on_service_error=self.peripheral_service_error,
on_advertising_started=self.peripheral_adv,
on_advertising_error=self.peripheral_adv,
on_characteristic_subscribed=self.char_sub,
on_characteristic_write=self.char_write)
self.scanning = ble_central.is_scanning
Clock.schedule_interval(self.update_list, 0.5)
def click(self):
if self.tst.is_running == 0:
self.tst.is_running = 1
self.txt = 'Starting'
self.btn_txt = 'Stop'
if self.first_run:
self.first_run = False
Clock.schedule_interval(self.update_text, 0.2)
self.thread.start()
else:
if not self.thread.is_alive():
self.thread = Thread(target=self.tst.test_run)
self.thread.start()
else:
self.tst.stop = 1
def __init__(self, **kwargs):
super(ZbarQrcodeDetector, self).__init__(**kwargs)
# my code
#
self.add_widget(self.labell)
def Course_thread(dt):
self.labell.text = "24923849"
self._examplefunc()
print "r"
#self.examplefunc("rrrr")
#self._send_request_dzyk(
# 'bal_sum/', params=None,
# success=self._get_commands_result_dzyk_balance_allsum, error=self._get_commands_error_dzyk)
Clock.schedule_interval(Course_thread, 1)
# ID of the command being executed
self._cmd_id = None
# List of the "completed" statuses.
# The first status should be "Done"
self._completed = []
# If True - sends a request to retrieve a command status
self._wait_completion = False
# requested command
self._command = (0, '')
#----------------------------------
self._camera = AndroidCamera(
size=self.camera_size,
size_hint=(None, None))
self._camera.bind(on_preview_frame=self._detect_qrcode_frame)
self.add_widget(self._camera)
# create a scanner used for detecting qrcode
self._scanner = ImageScanner()
self._scanner.setConfig(0, Config.ENABLE, 0)
self._scanner.setConfig(Symbol.QRCODE, Config.ENABLE, 1)
self._scanner.setConfig(0, Config.X_DENSITY, 3)
self._scanner.setConfig(0, Config.Y_DENSITY, 3)
def build(self):
sc = ScreenManager()
sc1 = MainView(name="main_sc")
sc2 = Style_Camera_Selection(name="sub1_sc")
sc3 = ContentSelection(name="sub2_sc")
sc4 = StyleSelection(name="sub3_sc")
sc5 = LocationSelection(name="sub4_sc")
sc1.callback()
Clock.schedule_interval(sc1.update, 1.0 / 60)
sc.add_widget(sc1)
sc.add_widget(sc2)
sc.add_widget(sc3)
sc.add_widget(sc4)
sc.add_widget(sc5)
sc.current = "main_sc"
return sc
def __init__(self, capteur, **kvargs):
super().__init__(**kvargs)
self.g = []
self.L = 300
self.H = 200
self.graphX = []
self.graphY = []
self.y_mid = self.H / 2
self.capteur = capteur
self.titre = self.capteur.nom
self.label_titre = Label(text=self.titre,
color=(1, 0.5, 0),
text_size=(self.width, self.height),
size_hint=(1, 2),
padding_y=0)
self.add_widget(self.label_titre)
Clock.schedule_interval(self.update, FREQ)
self.temps = 0
pas = int(300 / 10 * FREQ)
# pas = 3
self.max_graph = int(10 / FREQ)
# max_graph = 90
if self.capteur.nom == "Altitude":
self.graphY = [0] * self.max_graph
for i in range(0, self.max_graph):
self.graphX.append(pas * i)
else:
self.graphY = [self.y_mid] * self.max_graph
for i in range(0, self.max_graph):
self.graphX.append(pas * i)
self.N = 0
for i in range(0, 10):
mylabel = CoreLabel(text=str(i - 9),
font_size=15,
color=(1, 1, 1, 1))
# Force refresh to compute things and generate the texture
mylabel.refresh()
# Get the texture and the texture size
texture = mylabel.texture
texture_size = list(texture.size)
self.g.append(
Rectangle(pos=(17 + i * 30, 100),
texture=texture,
size=texture_size))
def fire_cannon(self):
self.cannonball.pos = (int(self.cannon.pos[0] + cos(radians(self.angle))
* self.cannon.size[0] / 2),
int(self.cannon.pos[1] + sin(radians(self.angle))
* self.cannon.size[1] / 2))
self.velocity_clock = Clock.schedule_interval(self.drop, 0.1)
self.velocity_y = self.velocity * (self.angle / 90)
self.velocity_x = self.velocity - self.velocity_y
def on_pre_enter(self, *args):
app = App.get_running_app()
tb = app.root.ids.toolbar
tb.left_action_items = [[
'arrow-left', lambda x: app.switch_to('joblist')
]]
tb.right_action_items = [['dots-vertical', lambda x: self.show_menu()]]
self.events.append(Clock.schedule_interval(self._update, 1))
def __init__(self, **kwargs):
super(MainWidget, self).__init__(**kwargs)
# print("INIT W: " + str(self.width) + "INIT H: " + str(self.height))
self.init_audio()
self.init_vertical_lines()
self.init_horizontal_lines()
self.init_tiles()
self.init_ship()
self.reset_game()
if self.is_desktop:
self._keyboard = Window.request_keyboard(self.keyboard_closed,
self)
self._keyboard.bind(on_key_down=self.on_keyboard_down)
self._keyboard.bind(on_key_up=self.on_keyboard_up)
Clock.schedule_interval(self.update, 1 / 60)
self.sound_galaxy.play()
def __init__(self, **kwargs):
super(MainWidget, self).__init__(**kwargs)
self.init_window_size()
Window.bind(on_request_close=self.on_request_close)
self.init_audio_files()
self.init_vertical_lines()
self.init_horizontal_lines()
#self.init_tiles()
self.init_ship() # must be called after init_tiles to be visible !
# add keyboard bindings
if self.is_desktop_platform():
self._keyboard = Window.request_keyboard(self.on_keyboard_closed, self)
self._keyboard.bind(on_key_down=self.on_keyboard_down)
self._keyboard.bind(on_key_up=self.on_keyboard_up)
# start the clock for update
Clock.schedule_interval(self.update, 1 / self.SPEED_FPS)
print(f"Clock started... \nStates: game_start={self.state_game_start} , game_over={self.state_game_start}")
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._game = Game()
self._current_speed_is_slow = True
self._update_background_size()
self._game.level_changed += self._update_background_size
self._running = False
self._game_timer_event = Clock.schedule_interval(
lambda dt: self._make_iteration(dt),
1.0 / self._game.iters_per_second)
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
screens = sm.screen_names
print len(screens)
print sm.current_screen !=sm.screens[0]
print "Name of current screen" + str(sm.current_screen)
if len(screens)>2 and sm.current_screen !=sm.screens[0]:
if keycode[1] == '0' or keycode[1] == 'numpad0':
print "before" + str(self.wrongploidy)
if self.wrongploidy ==False:
self.wrongploidy=True
self.popup = Popup(
title='Wrong Ploidy Selected',
size_hint=(None, None),
)
else:
self.wrongploidy=False
self.popup = Popup(
title='Right Ploidy ',
size_hint=(None, None),
)
print "After " + str(self.wrongploidy )
self.popup.open()
# call my_callback every 1 seconds
Clock.schedule_interval(self.close_popup, 1)
if keycode[1] == '5' or keycode[1] == 'numpad5':
self.rate_cell5(self.pages)
elif keycode[1] == '4' or keycode[1] == 'numpad4':
self.rate_cell4(self.pages)
elif keycode[1] == '3' or keycode[1] == 'numpad3':
self.rate_cell3(self.pages)
elif keycode[1] == '2' or keycode[1] == 'numpad2':
self.rate_cell2(self.pages)
elif keycode[1] == '1'or keycode[1] == 'numpad1':
self.rate_cell1(self.pages)
elif keycode[1] == 'backspace':
self.go_back()
elif keycode[1] == 'escape':
keyboard.release()
return True
def __init__(self, owner=None, **kwargs):
super(SpriteEditorViewer, self).__init__(**kwargs)
self.image = SpriteEditorImage(allow_stretch=True,
nocache=True,
size_hint=(None, None))
self.add_widget(self.image)
self.owner: 'SpriteEditorWidget' = owner
self.grid = SpriteEditorGrid(owner=self.image,
viewer=self,
size_hint=(None, None))
self.add_widget(self.grid)
self._tool: Generic[Tool] = None
self.tool = PanZoomTool()
self.selection = RegionSelection(viewer=self)
self.add_widget(self.selection)
Clock.schedule_interval(partial(self.update_info_callback), 0.05)
def buttonTrack(self, num):
"""再生リスト"""
if (num + 7 * self.flag) < len(self.track):
# 再生中の曲を止める
pygame.mixer.music.stop()
Clock.unschedule(self.position)
self.ids.slider.value = 0
Holder.setSlideValue(self.ids.slider.value)
# 選択したところの曲の再生
Holder.setTrackNum(num + 7 * self.flag)
pygame.mixer.music.load(self.track[Holder.getTrackNum()])
self.sound_kivy = SoundLoader.load(
self.track[Holder.getTrackNum()])
pygame.mixer.music.play()
Clock.schedule_interval(self.position, 0.1)
self.image_play = "image/pause.png"
# ファイルのパスの更新
Holder.setFilePath(self.track[Holder.getTrackNum()])
# ファイル名の取得
filename, ext = os.path.splitext(
os.path.basename(Holder.getFilePath()))
self.ids.label.text = filename
Holder.setFileName(filename)
Holder.setFilePath(Holder.getFilePath())
self.setImage_Lrc(Holder.getFileName())
Holder.setStatus("play")
# 歌詞の色を白にする
self.lrc_r, self.lrc_g, self.lrc_b = 1, 1, 1
self.wb_flag = 0
# ポップアップを閉じる
self.popup.dismiss()
else:
pass
def __init__(self, CtrlTir, **kwargs):
super().__init__(**kwargs)
self.CtrlTir = CtrlTir
self.angles = []
self.phases = []
Clock.schedule_interval(self.update, FREQ)
"""Paramètres de la mission à passer plus tard par une fenetre de parametres"""
self.phases.append("Launch")
self.phases.append("Separation")
self.phases.append("Landing")
self.angles.append(90)
self.angles.append(76)
self.angles.append(38)
self.affiche_timer("T+00:00:00", 26, 430, 30)
for i in range(0, len(self.phases)):
a = 700 * cos(self.angles[i] / 180 * pi)
b = 700 * sin(self.angles[i] / 180 * pi)
with self.canvas:
Color(1, 1, 1)
Line(circle=(500 + a, b - 600, 7))
self.affiche_timer(self.phases[i], 13, 485 + a, b - 590)
def buttonBack(self):
"""戻るボタンクリック時"""
if Holder.getTrackNum() - 1 >= 0:
# 再生中の曲を止める
pygame.mixer.music.stop()
self.ids.slider.value = 0
Holder.setSlideValue(self.ids.slider.value)
Clock.unschedule(self.position)
self.sound_kivy.unload()
# 一個前の曲の再生
Holder.setTrackNum(Holder.getTrackNum() - 1)
pygame.mixer.music.load(self.track[Holder.getTrackNum()])
self.sound_kivy = SoundLoader.load(
self.track[Holder.getTrackNum()])
pygame.mixer.music.play()
Clock.schedule_interval(self.position, 0.1)
self.image_play = "image/pause.png"
# ファイルのパスの更新
Holder.setFilePath(self.track[Holder.getTrackNum()])
# ファイル名の取得
filename, ext = os.path.splitext(
os.path.basename(Holder.getFilePath()))
self.ids.label.text = filename
Holder.setFileName(filename)
Holder.setFilePath(Holder.getFilePath())
self.setImage_Lrc(Holder.getFileName())
Holder.setStatus("play")
# 歌詞の色を白にする
self.lrc_r, self.lrc_g, self.lrc_b = 1, 1, 1
self.wb_flag = 0
else:
pass
def on_enter(self, *args):
self.animation_scheduler = Clock.schedule_interval(self.saver.update, 1.0 / 30.0)
def start(self):
'''Start the label updating in a separated thread
'''
Clock.schedule_interval(self.update_text, 0.2)
def build(self):
gra = GraPong()
gra.serw_pilki()
Clock.schedule_interval(gra.odswiez, 1.0/60.0)
return gra
def __init__(self, **kwargs):
super(RefTreeWidget, self).__init__(**kwargs)
# update_tree will be call each 4 seconds
# FIXME The line below has to be uncommented after fixing the reference duplication BUG!
Clock.schedule_interval(self.update_ref, 20)
def callback(self, dt):
self.manager.current = 'board1'
self.popup1.open()
self.current = 0
Clock.schedule_interval(self.my_callback, 1.0)
def __init__(self, *args, **kwargs):
super(Game, self).__init__(**kwargs)
print('game init hit')
Clock.schedule_interval(self.set_fps, .2)
def on_start(self):
Clock.schedule_interval(self.update, 0)
