def _mainloop(self): EventLoop.idle() for event in pygame.event.get(): # kill application (SIG_TERM) if event.type == pygame.QUIT: EventLoop.quit = True self.close() # mouse move elif event.type == pygame.MOUSEMOTION: # don't dispatch motion if no button are pressed if event.buttons == (0, 0, 0): continue x, y = event.pos self.dispatch('on_mouse_move', x, y, self.modifiers) # mouse action elif event.type in (pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): self._pygame_update_modifiers() x, y = event.pos btn = 'left' if event.button == 3: btn = 'right' elif event.button == 2: btn = 'middle' eventname = 'on_mouse_down' if event.type == pygame.MOUSEBUTTONUP: eventname = 'on_mouse_up' self.dispatch(eventname, x, y, btn, self.modifiers) # keyboard action elif event.type in (pygame.KEYDOWN, pygame.KEYUP): self._pygame_update_modifiers(event.mod) # atm, don't handle keyup if event.type == pygame.KEYUP: self.dispatch('on_key_up', event.key, event.scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', event.key, event.scancode, event.unicode): continue self.dispatch('on_keyboard', event.key, event.scancode, event.unicode) # video resize elif event.type == pygame.VIDEORESIZE: pass # ignored event elif event.type in (pygame.ACTIVEEVENT, pygame.VIDEOEXPOSE): pass # unhandled event ! else: Logger.debug('WinPygame: Unhandled event %s' % str(event))
def test_scrollbar_both_margin(self): EventLoop.ensure_window() win = EventLoop.window grid = TestGrid() scroll = TestScrollbarBothMargin() margin = scroll.bar_margin scroll.add_widget(grid) win.add_widget(scroll) # get widgets ready EventLoop.idle() left, right = scroll.to_window(scroll.x, scroll.right) bottom, top = scroll.to_window(scroll.y, scroll.top) # touch in the half of the bar m = margin + scroll.bar_width / 2.0 points = [ [left, bottom + m, right, bottom + m, 'bottom', 'right', False], [left, top - m, right, top - m, 'top', 'right', False], [right - m, top, right - m, bottom, 'bottom', 'right', False], [left + m, top, left + m, bottom, 'bottom', 'left', False], [left, bottom, right, bottom, 'bottom', 'right', True], [left, top, right, top, 'top', 'right', True], [right, top, right, bottom, 'bottom', 'right', True], [left, top, left, bottom, 'bottom', 'left', True] ] self.process_points(scroll, points) self.render(scroll)
def PopupOk(text, title='', btn_text='Continue', input=None, callback=None): btnclose = Button(text=btn_text, size_hint_y=None, height='50sp') content = BoxLayout(orientation='vertical') p = Popup(title=title, content=content, size=('300dp', '300dp'), size_hint=(None, None), pos_hint={'top':.95}) content.add_widget(Label(text=text)) if input is not None: assert callback is not None ti = TextInput(height='50sp', font_size='30sp', input_type=input, multiline=False, size_hint_y = None, focus=True) content.add_widget(ti) def _callback(*args): try: ti.hide_keyboard() except AttributeError: # On a real computer, not the phone pass if ti.text == '': callback(None) else: callback(ti.text) p.bind(on_dismiss=_callback) p.is_visable = True content.add_widget(btnclose) btnclose.bind(on_release=p.dismiss) p.open() if input is not None: while not p.is_visable: EventLoop.idle() return ti.text
def inner(*args): #Here is hould loop on the template to apply them on values from kivy.base import EventLoop EventLoop.idle() pim = tmpl.toPILImage(for_print = True).rotate(90) pm.setImage(pim) self.stack.add_widget(pm)
def inner(*args): #Here is hould loop on the template to apply them on values from kivy.base import EventLoop EventLoop.idle() cim = tmpl.toImage() cim.texture.flip_vertical() self.ids['img'].texture = cim.texture
def __init__(self,parent,**kwargs): from kivy.base import EventLoop self.result=None dlg = MessageBox(parent,**kwargs) while (dlg) and (self.result is None): EventLoop.idle() return self.result
def advance_real_time(self, secs=.1): start = self._current_time while self._current_time < start + secs: EventLoop.idle() sleep(1 / self._fps) self._current_time += 1 / self._fps EventLoop.idle()
def add_item(self, qt, verso): from os.path import relpath stack = App.get_running_app().root.ids['deck'].ids['stack'] ########################################################## qt = int(qt) if self.is_all_folder: #print self, self.source, self.name, self.is_all_folder #It is a folder, add all the imge from folder for name in [x for x in os.listdir(self.is_all_folder) if x.endswith(FILE_FILTER)]: ##for fiv in self.parent.children: ##if fiv.is_all_folder: continue if name.endswith(('.csv','.xlsx')): continue box = StackPart() #box.name = fiv.name box.name = name box.source = os.path.join(self.is_all_folder, name) box.qt = qt box.verso = verso if name.endswith('.kv'): if self.is_all_folder.startswith(gamepath): fold = relpath(self.is_all_folder, gamepath) else: fold = self.is_all_folder box.template = "@%s"%os.path.join(fold, name) box.realise() stack.add_widget(box) from kivy.base import EventLoop EventLoop.idle() elif self.name.endswith('.csv'): App.get_running_app().root.ids.deck.load_file_csv(self.name) elif self.name.endswith('.xlsx'): App.get_running_app().root.ids.deck.load_file(self.name) elif self.name.endswith('.bgp'): self.extract_package() elif self.name.endswith('.py'): print 'should be executing', self.name, self.source, self.is_all_folder from imp import load_source Logger.info('Executing PYScript file %s'%self.name) m = self.name load_source(m[:-3],m) else: box = StackPart() box.name = self.name box.source = self.source box.qt = qt box.verso = verso stack.add_widget(box) if self.name.endswith('.kv'): box.tmplWidget = self.tmplWidget if self.name.startswith(gamepath): fold = relpath(self.name, gamepath) else: fold = self.name box.template = "@%s"%fold box.realise()
def advance_frames(self, count): """ Borrowed from Kivy 1.10.0+ /kivy/tests/common.py GraphicUnitTest.advance_frames() Makes it possible to to wait for UI to process, refs #110. """ from kivy.base import EventLoop for i in range(count): EventLoop.idle()
def __init__(self, raw_x, raw_y): win = EventLoop.window super().__init__("unittest", 1, { "x": raw_x / float(win.width), "y": raw_y / float(win.height), }) # press & release EventLoop.post_dispatch_input("begin", self) EventLoop.post_dispatch_input("end", self) EventLoop.idle()
def idle_until(condition, timeout=None, msg="Timed out"): if timeout is None: while not condition(): EventLoop.idle() return for _ in range(timeout): if condition(): return EventLoop.idle() raise TimeoutError(msg)
def update(self, value): self.value = value if 0.0 < value < 100.0: self.opacity = 1.0 else: self.opacity = 0.0 if time.time() - self.last_update > self.frame_time: EventLoop.idle() self.last_update = time.time()
def advance_frames(self, count): '''Render the new frames and: * tick the Clock * dispatch input from all registered providers * flush all the canvas operations * redraw Window canvas if necessary ''' from kivy.base import EventLoop for i in range(count): EventLoop.idle()
def advance_frames(self, count): '''Render the new frames and: * tick the Clock * dispatch input from all registered providers * flush all the canvas operations * redraw Window canvas if necessary ''' from kivy.base import EventLoop for i in range(count): EventLoop.idle()
def alert(self, text="", status_color=(0, 0, 0, 1), keep = False): button = self.root.ids.message bar = self.root.ids.message_bar bar.background_color = status_color button.text = str(text) from kivy.base import EventLoop EventLoop.idle() if not keep: from kivy.clock import Clock def cb(*args): self.alert(keep=True) Clock.schedule_once(cb, 2)
def __init__(self, raw_x, raw_y): win = EventLoop.window super(UTMotionEvent, self).__init__( "unittest", 1, { "x": raw_x / float(win.width), "y": raw_y / float(win.height), } ) # press & release EventLoop.post_dispatch_input("begin", self) EventLoop.post_dispatch_input("end", self) EventLoop.idle()
def alert(self, text="", status_color=(0, 0, 0, 1), keep=False): button = self.root.ids.message bar = self.root.ids.message_bar bar.background_color = status_color button.text = str(text) from kivy.base import EventLoop EventLoop.idle() if not keep: from kivy.clock import Clock def cb(*args): self.alert(keep=True) Clock.schedule_once(cb, 2)
def test_layout_grid(): spots_wide = 3 spots_tall = 3 graph = nx.grid_2d_graph(spots_wide, spots_tall) char = Facade(graph) app = ELiDEApp() spotlayout = FinalLayout() arrowlayout = FinalLayout() board = GraphBoard(app=app, character=char, spotlayout=spotlayout, arrowlayout=arrowlayout) spotlayout.pos = board.pos board.bind(pos=spotlayout.setter('pos')) spotlayout.size = board.size board.bind(size=spotlayout.setter('size')) board.add_widget(spotlayout) arrowlayout.pos = board.pos board.bind(pos=arrowlayout.setter('pos')) arrowlayout.size = board.size board.bind(size=arrowlayout.setter('size')) board.add_widget(arrowlayout) board.update() boardview = GraphBoardView(board=board) EventLoop.ensure_window() win = EventLoop.window win.add_widget(boardview) def all_spots_placed(): for x in range(spots_wide): for y in range(spots_tall): if (x, y) not in board.spot: return False return True while not all_spots_placed(): EventLoop.idle() # Don't get too picky about the exact proportions of the grid; just make sure the # spots are positioned logically with respect to one another for name, spot in board.spot.items(): x, y = name if x > 0: assert spot.x > board.spot[x - 1, y].x if y > 0: assert spot.y > board.spot[x, y - 1].y if x < spots_wide - 1: assert spot.x < board.spot[x + 1, y].x if y < spots_tall - 1: assert spot.y < board.spot[x, y + 1].y
def test_scrollbar_vertical(self): EventLoop.ensure_window() win = EventLoop.window grid = _TestGrid() scroll = _TestScrollbarVertical() scroll.add_widget(grid) win.add_widget(scroll) # get widgets ready EventLoop.idle() left, right = scroll.to_window(scroll.x, scroll.right) bottom, top = scroll.to_window(scroll.y, scroll.top) points = [[right, top, right, bottom, 'bottom', 'right', False], [left, top, left, bottom, 'bottom', 'left', False]] self.process_points(scroll, points) self.render(scroll)
def test_scrollbar_vertical(self): EventLoop.ensure_window() win = EventLoop.window grid = TestGrid() scroll = TestScrollbarVertical() scroll.add_widget(grid) win.add_widget(scroll) # get widgets ready EventLoop.idle() left, right = scroll.to_window(scroll.x, scroll.right) bottom, top = scroll.to_window(scroll.y, scroll.top) points = [ [right, top, right, bottom, 'bottom', 'right', False], [left, top, left, bottom, 'bottom', 'left', False] ] self.process_points(scroll, points) self.render(scroll)
def rpc_drag(selector, target, duration): from kivy.base import EventLoop w1 = selectFirst(selector) w2 = selectFirst(target) duration = float(duration) if w1 and w2: from kivy.core.window import Window cx1, cy1 = w1.to_window(w1.center_x, w1.center_y) sx1 = cx1 / float(Window.width) sy1 = cy1 / float(Window.height) me = TeleniumMotionEvent("telenium", id=next(nextid), args=[sx1, sy1]) telenium_input.events.append(("begin", me)) if not duration: telenium_input.events.append(("end", me)) else: d = 0 while d < duration: t = time() EventLoop.idle() dt = time() - t # need to compute that ever frame, it could have moved cx2, cy2 = w2.to_window(w2.center_x, w2.center_y) sx2 = cx2 / float(Window.width) sy2 = cy2 / float(Window.height) dsx = dt * (sx2 - me.sx) / (duration - d) dsy = dt * (sy2 - me.sy) / (duration - d) me.sx += dsx me.sy += dsy telenium_input.events.append(("update", me)) d += dt telenium_input.events.append(("end", me)) return True
def _event_filter(self, action, *largs): from kivy.app import App if action == 'app_terminating': EventLoop.quit = True elif action == 'app_lowmemory': self.dispatch('on_memorywarning') elif action == 'app_willenterbackground': from kivy.base import stopTouchApp app = App.get_running_app() if not app: Logger.info('WindowSDL: No running App found, exit.') stopTouchApp() return 0 if not app.dispatch('on_pause'): Logger.info( 'WindowSDL: App doesn\'t support pause mode, stop.') stopTouchApp() return 0 self._pause_loop = True elif action == 'app_didenterforeground': # on iOS, the did enter foreground is launched at the start # of the application. in our case, we want it only when the app # is resumed if self._pause_loop: self._pause_loop = False app = App.get_running_app() app.dispatch('on_resume') elif action == 'windowresized': self._size = largs self._win.resize_window(*self._size) # Force kivy to render the frame now, so that the canvas is drawn. EventLoop.idle() return 0
def _event_filter(self, action, *largs): from kivy.app import App if action == 'app_terminating': EventLoop.quit = True elif action == 'app_lowmemory': self.dispatch('on_memorywarning') elif action == 'app_willenterbackground': from kivy.base import stopTouchApp app = App.get_running_app() if not app: Logger.info('WindowSDL: No running App found, exit.') stopTouchApp() return 0 if not app.dispatch('on_pause'): Logger.info( 'WindowSDL: App doesn\'t support pause mode, stop.') stopTouchApp() return 0 self._pause_loop = True elif action == 'app_didenterforeground': # on iOS, the did enter foreground is launched at the start # of the application. in our case, we want it only when the app # is resumed if self._pause_loop: self._pause_loop = False app = App.get_running_app() app.dispatch('on_resume') elif action == 'windowresized': self._size = largs self._win.resize_window(*self._size) # Force kivy to render the frame now, so that the canvas is drawn. EventLoop.idle() return 0
def linearize(self,progressbar = None): #transform all stack with qt>1 to as many stack with qt 1 cs = self.ids.stack.children[:] cs.reverse() dst = list() if progressbar: from kivy.base import EventLoop progressbar.value = 0 progressbar.max = len(cs) * 2 for c in cs: if progressbar: progressbar.value+=1 EventLoop.idle() for _ in range(c.qt): d = c.Copy() d.qt = 1 dst.append(d) self.ids.stack.clear_widgets() for d in dst: if progressbar: progressbar.value += 1 EventLoop.idle() self.ids.stack.add_widget(d) d.realise(use_cache=True)
def linearize(self, progressbar=None): #transform all stack with qt>1 to as many stack with qt 1 cs = self.ids.stack.children[:] cs.reverse() dst = list() if progressbar: from kivy.base import EventLoop progressbar.value = 0 progressbar.max = len(cs) * 2 for c in cs: if progressbar: progressbar.value += 1 EventLoop.idle() for _ in range(c.qt): d = c.Copy() d.qt = 1 dst.append(d) self.ids.stack.clear_widgets() for d in dst: if progressbar: progressbar.value += 1 EventLoop.idle() self.ids.stack.add_widget(d) d.realise(use_cache=True)
def _start_app_as_slave(self): # from app::run if not self.mc.built: self.mc.load_config() self.mc.load_kv(filename=self.mc.kv_file) root = self.mc.build() if root: self.mc.root = root if self.mc.root: if not isinstance(self.mc.root, KivyWidget): Logger.critical( 'App.root must be an _instance_ of Kivy Widget') raise Exception('Invalid instance in App.root') from kivy.core.window import Window Window.add_widget(self.mc.root) # Check if the window is already created from kivy.base import EventLoop window = EventLoop.window if window: self.mc._app_window = window window.set_title(self.mc.get_application_name()) icon = self.mc.get_application_icon() if icon: window.set_icon(icon) self.mc._install_settings_keys(window) else: Logger.critical("Application: No window is created." " Terminating application run.") return self.mc.dispatch('on_start') runTouchApp(slave=True) # change is here while not self.mc.is_init_done.is_set(): EventLoop.idle()
def test_scrollbar_vertical_margin(self): EventLoop.ensure_window() win = EventLoop.window grid = _TestGrid() scroll = _TestScrollbarVerticalMargin() margin = scroll.bar_margin scroll.add_widget(grid) win.add_widget(scroll) # get widgets ready EventLoop.idle() left, right = scroll.to_window(scroll.x, scroll.right) bottom, top = scroll.to_window(scroll.y, scroll.top) # touch in the half of the bar m = margin + scroll.bar_width / 2.0 points = [[ right - m, top, right - m, bottom, 'bottom', 'right', False ], [left + m, top, left + m, bottom, 'bottom', 'left', False], [right, top, right, bottom, 'bottom', 'right', True], [left, top, left, bottom, 'bottom', 'left', True]] self.process_points(scroll, points) self.render(scroll)
def scanAllEcus(self): SEFname = mod_globals.user_data_dir + '/savedEcus.p' if mod_globals.opt_can2: SEFname = mod_globals.user_data_dir + '/savedEcus2.p' if mod_globals.opt_demo and not os.path.isfile(SEFname): SEFname = './savedEcus.p' if os.path.isfile(SEFname) and not mod_globals.opt_scan: self.detectedEcus = pickle.load(open(SEFname, 'rb')) if len(self.detectedEcus ) > 0 and 'idTx' not in self.detectedEcus[0].keys(): self.allecus = OrderedDict() for i in self.detectedEcus: self.allecus[i['ecuname']] = i self.read_Uces_file() self.detectedEcus = [] for i in self.allecus.keys(): self.detectedEcus.append(self.allecus[i]) self.detectedEcus = sorted(self.detectedEcus, key=lambda k: int(k['idf'])) if len(self.detectedEcus): pickle.dump(self.detectedEcus, open(SEFname, 'wb')) return None mod_globals.opt_scan = True mod_globals.state_scan = True lbltxt = Label(text='Init', font_size=20) popup_scan = Popup(title='Scanning CAN bus', content=lbltxt, size=(400, 400), size_hint=(None, None)) base.runTouchApp(slave=True) popup_scan.open() EventLoop.idle() self.reqres = [] self.errres = [] i = 0 lbltxt.text = 'Scanning:' + str(i) + '/' + str(len( self.allecus)) + ' Detected: ' + str(len(self.detectedEcus)) EventLoop.idle() canH = '6' canL = '14' if mod_globals.opt_can2: canH = '13' canL = '12' self.elm.init_can() for ecu, row in sorted(self.allecus.iteritems(), key=lambda (x, y): y['idf'] + y['protocol']): if self.allecus[ecu]['pin'] == 'can' and self.allecus[ecu][ 'pin1'] == canH and self.allecus[ecu]['pin2'] == canL: i = i + 1 lbltxt.text = 'Scanning:' + str(i) + '/' + str( len(self.allecus)) + ' Detected: ' + str( len(self.detectedEcus)) EventLoop.idle() self.elm.set_can_addr(self.allecus[ecu]['dst'], self.allecus[ecu]) self.scan_can(self.allecus[ecu]) self.elm.close_protocol() if not mod_globals.opt_can2: popup_scan.title = 'Scanning ISO bus' self.elm.init_iso() for ecu, row in sorted(self.allecus.iteritems(), key=lambda (x, y): y['idf'] + y['protocol']): if self.allecus[ecu]['pin'] == 'iso' and self.allecus[ecu][ 'pin1'] == '7' and self.allecus[ecu]['pin2'] == '15': i = i + 1 lbltxt.text = 'Scanning:' + str(i) + '/' + str( len(self.allecus)) + ' Detected: ' + str( len(self.detectedEcus)) EventLoop.idle() self.elm.set_iso_addr(self.allecus[ecu]['dst'], self.allecus[ecu]) self.scan_iso(self.allecus[ecu]) lbltxt.text = 'Scanning:' + str(i) + '/' + str(len( self.allecus)) + ' Detected: ' + str(len(self.detectedEcus)) EventLoop.idle() mod_globals.state_scan = False self.detectedEcus = sorted(self.detectedEcus, key=lambda k: int(k['idf'])) if len(self.detectedEcus): pickle.dump(self.detectedEcus, open(SEFname, 'wb')) EventLoop.window.remove_widget(popup_scan) popup_scan.dismiss() base.stopTouchApp() EventLoop.window.canvas.clear() del popup_scan
def _mainloop(self): EventLoop.idle() for event in pygame.event.get(): # kill application (SIG_TERM) if event.type == pygame.QUIT: if self.dispatch('on_request_close'): continue EventLoop.quit = True self.close() # mouse move elif event.type == pygame.MOUSEMOTION: x, y = event.pos self.mouse_pos = x, self.system_size[1] - y # don't dispatch motion if no button are pressed if event.buttons == (0, 0, 0): continue self._mouse_x = x self._mouse_y = y self._mouse_meta = self.modifiers self.dispatch('on_mouse_move', x, y, self.modifiers) # mouse action elif event.type in (pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): self._pygame_update_modifiers() x, y = event.pos btn = 'left' if event.button == 3: btn = 'right' elif event.button == 2: btn = 'middle' elif event.button == 4: btn = 'scrolldown' elif event.button == 5: btn = 'scrollup' elif event.button == 6: btn = 'scrollright' elif event.button == 7: btn = 'scrollleft' eventname = 'on_mouse_down' if event.type == pygame.MOUSEBUTTONUP: eventname = 'on_mouse_up' self._mouse_x = x self._mouse_y = y self._mouse_meta = self.modifiers self._mouse_btn = btn self._mouse_down = eventname == 'on_mouse_down' self.dispatch(eventname, x, y, btn, self.modifiers) # keyboard action elif event.type in (pygame.KEYDOWN, pygame.KEYUP): self._pygame_update_modifiers(event.mod) # atm, don't handle keyup if event.type == pygame.KEYUP: self.dispatch('on_key_up', event.key, event.scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', event.key, event.scancode, event.unicode, self.modifiers): continue self.dispatch('on_keyboard', event.key, event.scancode, event.unicode, self.modifiers) # video resize elif event.type == pygame.VIDEORESIZE: self._size = event.size self.update_viewport() elif event.type == pygame.VIDEOEXPOSE: self.canvas.ask_update() # ignored event elif event.type == pygame.ACTIVEEVENT: pass # drop file (pygame patch needed) elif event.type == pygame.USEREVENT and \ hasattr(pygame, 'USEREVENT_DROPFILE') and \ event.code == pygame.USEREVENT_DROPFILE: self.dispatch('on_dropfile', event.filename) '''
def _mainloop(self): EventLoop.idle() while True: event = sdl.poll() if event is False: break if event is None: continue action, args = event[0], event[1:] if action == 'quit': EventLoop.quit = True self.close() break elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider SDLMotionEventProvider.q.appendleft(event) if action == 'mousemotion': x, y = args self.dispatch('on_mouse_move', x, y, self.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' if action == 'mousebuttonup': eventname = 'on_mouse_up' self.dispatch(eventname, x, y, btn, self.modifiers) # video resize elif action == 'windowresized': self._size = args # don't use trigger here, we want to delay the resize event cb = self._do_resize Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif action == 'windowresized': self.canvas.ask_update() elif action == 'windowminimized': self.do_pause() elif action == 'windowrestored': pass elif action in ('keydown', 'keyup'): mod, key, scancode, str = args # XXX ios keyboard suck, when backspace is hit, the delete # keycode is sent. fix it. if key == 127: key = 8 self._pygame_update_modifiers(mod) if action == 'keyup': self.dispatch('on_key_up', key, scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', key, scancode, str, self.modifiers): continue self.dispatch('on_keyboard', key, scancode, str, self.modifiers) elif action == 'textinput': key = args[0][0] # XXX on IOS, keydown/up don't send unicode anymore. # With latest sdl, the text is sent over textinput # Right now, redo keydown/up, but we need to seperate both call # too. (and adapt on_key_* API.) self.dispatch('on_key_down', key, None, args[0], self.modifiers) self.dispatch('on_keyboard', None, None, args[0], self.modifiers) self.dispatch('on_key_up', key, None, args[0], self.modifiers)
def _mainloop(self): EventLoop.idle() # for android/iOS, we don't want to have any event nor executing our # main loop while the pause is going on. This loop wait any event (not # handled by the event filter), and remove them from the queue. # Nothing happen during the pause on iOS, except gyroscope value sent # over joystick. So it's safe. while self._pause_loop: self._win.wait_event() if not self._pause_loop: break self._win.poll() while True: event = self._win.poll() if event is False: break if event is None: continue action, args = event[0], event[1:] if action == 'quit': if self.dispatch('on_request_close'): continue EventLoop.quit = True self.close() break elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider # XXX this is problematic. On OSX, it generates touches with 0, # 0 coordinates, at the same times as mouse. But it works. # We have a conflict of using either the mouse or the finger. # Right now, we have no mechanism that we could use to know # which is the preferred one for the application. if platform in ('ios', 'android'): SDL2MotionEventProvider.q.appendleft(event) pass elif action == 'mousemotion': x, y = args x, y = self._fix_mouse_pos(x, y) self._mouse_x = x self._mouse_y = y # don't dispatch motion if no button are pressed if len(self._mouse_buttons_down) == 0: continue self._mouse_meta = self.modifiers self.dispatch('on_mouse_move', x, y, self.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args x, y = self._fix_mouse_pos(x, y) btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' self._mouse_buttons_down.add(button) if action == 'mousebuttonup': eventname = 'on_mouse_up' self._mouse_buttons_down.remove(button) self._mouse_x = x self._mouse_y = y self.dispatch(eventname, x, y, btn, self.modifiers) elif action.startswith('mousewheel'): self._update_modifiers() x, y, button = args btn = 'scrolldown' if action.endswith('up'): btn = 'scrollup' elif action.endswith('right'): btn = 'scrollright' elif action.endswith('left'): btn = 'scrollleft' self._mouse_meta = self.modifiers self._mouse_btn = btn #times = x if y == 0 else y #times = min(abs(times), 100) #for k in range(times): self._mouse_down = True self.dispatch('on_mouse_down', self._mouse_x, self._mouse_y, btn, self.modifiers) self._mouse_down = False self.dispatch('on_mouse_up', self._mouse_x, self._mouse_y, btn, self.modifiers) elif action == 'dropfile': dropfile = args self.dispatch('on_dropfile', dropfile[0]) # video resize elif action == 'windowresized': self._size = self._win.window_size # don't use trigger here, we want to delay the resize event ev = self._do_resize_ev if ev is None: ev = self._do_resize_ev = Clock.schedule_once( self._do_resize, .1) else: ev() elif action == 'windowresized': self.canvas.ask_update() elif action == 'windowrestored': self.dispatch('on_restore') self.canvas.ask_update() elif action == 'windowexposed': self.canvas.ask_update() elif action == 'windowminimized': self.dispatch('on_minimize') if Config.getboolean('kivy', 'pause_on_minimize'): self.do_pause() elif action == 'windowmaximized': self.dispatch('on_maximize') elif action == 'windowhidden': self.dispatch('on_hide') elif action == 'windowshown': self.dispatch('on_show') elif action == 'windowfocusgained': self._focus = True elif action == 'windowfocuslost': self._focus = False elif action == 'windowenter': self.dispatch('on_cursor_enter') elif action == 'windowleave': self.dispatch('on_cursor_leave') elif action == 'joyaxismotion': stickid, axisid, value = args self.dispatch('on_joy_axis', stickid, axisid, value) elif action == 'joyhatmotion': stickid, hatid, value = args self.dispatch('on_joy_hat', stickid, hatid, value) elif action == 'joyballmotion': stickid, ballid, xrel, yrel = args self.dispatch('on_joy_ball', stickid, ballid, xrel, yrel) elif action == 'joybuttondown': stickid, buttonid = args self.dispatch('on_joy_button_down', stickid, buttonid) elif action == 'joybuttonup': stickid, buttonid = args self.dispatch('on_joy_button_up', stickid, buttonid) elif action in ('keydown', 'keyup'): mod, key, scancode, kstr = args try: key = self.key_map[key] except KeyError: pass if action == 'keydown': self._update_modifiers(mod, key) else: self._update_modifiers(mod) # ignore the key, it # has been released # if mod in self._meta_keys: if (key not in self._modifiers and key not in self.command_keys.keys()): try: kstr = unichr(key) except ValueError: pass #if 'shift' in self._modifiers and key\ # not in self.command_keys.keys(): # return if action == 'keyup': self.dispatch('on_key_up', key, scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', key, scancode, kstr, self.modifiers): continue self.dispatch('on_keyboard', key, scancode, kstr, self.modifiers) elif action == 'textinput': text = args[0] self.dispatch('on_textinput', text) # unhandled event ! else: Logger.trace('WindowSDL: Unhandled event %s' % str(event))
def test_slider_move(self): EventLoop.ensure_window() win = EventLoop.window layout = BoxLayout(orientation='vertical') s_handle = _TestSliderHandle() s_all = _TestSliderAll() layout.add_widget(s_handle) layout.add_widget(s_all) win.add_widget(layout) # get widgets ready EventLoop.idle() cur1 = s_handle.children[0] cur2 = s_all.children[0] h1 = cur1.to_window(*cur1.center)[1] h2 = h1 - s_handle.cursor_height h3 = cur2.to_window(*cur2.center)[1] h4 = h3 - s_all.cursor_height w1 = cur1.to_window(*cur1.center)[0] w2 = cur2.to_window(*cur2.center)[0] wh = win.width / 2.0 dt = 2 # default pos, new pos, slider ID points = [ [w1, h1, wh, h1, 'handle'], [w1, h2, wh, h2, 'handle'], [w2, h3, wh, h3, 'all'], [w2, h4, wh, h4, 'all'], ] for point in points: x, y, nx, ny, id = point # custom touch touch = UTMotionEvent("unittest", 1, { "x": x / float(win.width), "y": y / float(win.height), }) # touch down EventLoop.post_dispatch_input("begin", touch) if id == 'handle': # touch on handle if x == w1 and y == h1: self.assertAlmostEqual(s_handle.value, 0.0, delta=dt) # touch in widget area (ignored, previous value) elif x == w1 and y == h2: self.assertAlmostEqual(s_handle.value, 50.0, delta=dt) elif id == 'all': # touch on handle: if x == w1 and y == h3: self.assertAlmostEqual(s_all.value, 0.0, delta=dt) # touch in widget area elif x == w1 and y == h4: self.assertAlmostEqual(s_all.value, 0.0, delta=dt) # move from default to new pos touch.move({ "x": nx / float(win.width), "y": ny / float(win.height) }) EventLoop.post_dispatch_input("update", touch) if id == 'handle': # move from handle to center if nx == wh and ny == h1: self.assertAlmostEqual(s_handle.value, 50.0, delta=dt) # move to center (ignored, previous value) elif nx == wh and ny == h2: self.assertAlmostEqual(s_handle.value, 50.0, delta=dt) elif id == 'all': # touch on handle: if nx == wh and ny == h3: self.assertAlmostEqual(s_all.value, 50.0, delta=dt) # touch in widget area elif nx == wh and ny == h4: self.assertAlmostEqual(s_all.value, 50.0, delta=dt) # touch up EventLoop.post_dispatch_input("end", touch) self.render(layout)
def _mainloop(self): EventLoop.idle() while True: event = self._win.poll() if event is False: break if event is None: continue action, args = event[0], event[1:] if action == 'quit': if self.dispatch('on_request_close'): continue EventLoop.quit = True self.close() break elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider # XXX this is problematic. On OSX, it generates touches with 0, # 0 coordinates, at the same times as mouse. But it works. # We have a conflict of using either the mouse or the finger. # Right now, we have no mechanism that we could use to know # which is the preferred one for the application. if platform == "ios": SDL2MotionEventProvider.q.appendleft(event) pass elif action == 'mousemotion': x, y = args x, y = self._fix_mouse_pos(x, y) self._mouse_x = x self._mouse_y = y # don't dispatch motion if no button are pressed if len(self._mouse_buttons_down) == 0: continue self._mouse_meta = self.modifiers self.dispatch('on_mouse_move', x, y, self.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args x, y = self._fix_mouse_pos(x, y) btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' self._mouse_buttons_down.add(button) if action == 'mousebuttonup': eventname = 'on_mouse_up' self._mouse_buttons_down.remove(button) self._mouse_x = x self._mouse_y = y self.dispatch(eventname, x, y, btn, self.modifiers) elif action.startswith('mousewheel'): self._update_modifiers() x, y, button = args btn = 'scrolldown' if action.endswith('up'): btn = 'scrollup' elif action.endswith('right'): btn = 'scrollright' elif action.endswith('left'): btn = 'scrollleft' self._mouse_meta = self.modifiers self._mouse_btn = btn #times = x if y == 0 else y #times = min(abs(times), 100) #for k in range(times): self._mouse_down = True self.dispatch('on_mouse_down', self._mouse_x, self._mouse_y, btn, self.modifiers) self._mouse_down = False self.dispatch('on_mouse_up', self._mouse_x, self._mouse_y, btn, self.modifiers) elif action == 'dropfile': dropfile = args self.dispatch('on_dropfile', dropfile[0]) # video resize elif action == 'windowresized': self._size = self._win.window_size # don't use trigger here, we want to delay the resize event cb = self._do_resize Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif action == 'windowresized': self.canvas.ask_update() elif action == 'windowrestored': self.canvas.ask_update() elif action == 'windowexposed': self.canvas.ask_update() elif action == 'windowminimized': if Config.getboolean('kivy', 'pause_on_minimize'): self.do_pause() elif action == 'joyaxismotion': stickid, axisid, value = args self.dispatch('on_joy_axis', stickid, axisid, value) elif action == 'joyhatmotion': stickid, hatid, value = args self.dispatch('on_joy_hat', stickid, hatid, value) elif action == 'joyballmotion': stickid, ballid, xrel, yrel = args self.dispatch('on_joy_ball', stickid, ballid, xrel, yrel) elif action == 'joybuttondown': stickid, buttonid = args self.dispatch('on_joy_button_down', stickid, buttonid) elif action == 'joybuttonup': stickid, buttonid = args self.dispatch('on_joy_button_up', stickid, buttonid) elif action in ('keydown', 'keyup'): mod, key, scancode, kstr = args key_swap = { SDLK_LEFT: 276, SDLK_RIGHT: 275, SDLK_UP: 273, SDLK_DOWN: 274, SDLK_HOME: 278, SDLK_END: 279, SDLK_PAGEDOWN: 281, SDLK_PAGEUP: 280, SDLK_SHIFTR: 303, SDLK_SHIFTL: 304, SDLK_SUPER: 309, SDLK_LCTRL: 305, SDLK_RCTRL: 306, SDLK_LALT: 308, SDLK_RALT: 307, SDLK_CAPS: 301, SDLK_INSERT: 277, SDLK_F1: 282, SDLK_F2: 283, SDLK_F3: 284, SDLK_F4: 285, SDLK_F5: 286, SDLK_F6: 287, SDLK_F7: 288, SDLK_F8: 289, SDLK_F9: 290, SDLK_F10: 291, SDLK_F11: 292, SDLK_F12: 293, SDLK_F13: 294, SDLK_F14: 295, SDLK_F15: 296, SDLK_KEYPADNUM: 300, SDLK_KP_DEVIDE: 267, SDLK_KP_MULTIPLY: 268, SDLK_KP_MINUS: 269, SDLK_KP_PLUS: 270, SDLK_KP_ENTER: 271, SDLK_KP_DOT: 266, SDLK_KP_0: 256, SDLK_KP_1: 257, SDLK_KP_2: 258, SDLK_KP_3: 259, SDLK_KP_4: 260, SDLK_KP_5: 261, SDLK_KP_6: 262, SDLK_KP_7: 263, SDLK_KP_8: 264, SDLK_KP_9: 265} if platform == 'ios': # XXX ios keyboard suck, when backspace is hit, the delete # keycode is sent. fix it. key_swap[127] = 8 # back try: key = key_swap[key] except KeyError: pass if action == 'keydown': self._update_modifiers(mod, key) else: self._update_modifiers(mod) # ignore the key, it # has been released # if mod in self._meta_keys: if (key not in self._modifiers and key not in self.command_keys.keys()): try: kstr = unichr(key) except ValueError: pass #if 'shift' in self._modifiers and key\ # not in self.command_keys.keys(): # return if action == 'keyup': self.dispatch('on_key_up', key, scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', key, scancode, kstr, self.modifiers): continue self.dispatch('on_keyboard', key, scancode, kstr, self.modifiers) elif action == 'textinput': text = args[0] self.dispatch('on_textinput', text) # XXX on IOS, keydown/up don't send unicode anymore. # With latest sdl, the text is sent over textinput # Right now, redo keydown/up, but we need to seperate both call # too. (and adapt on_key_* API.) #self.dispatch() #self.dispatch('on_key_down', key, None, args[0], # self.modifiers) #self.dispatch('on_keyboard', None, None, args[0], # self.modifiers) #self.dispatch('on_key_up', key, None, args[0], # self.modifiers) # unhandled event ! else: Logger.trace('WindowSDL: Unhandled event %s' % str(event))
def _mainloop(self): EventLoop.idle()
def move_frames(self, t): for i in range(t): EventLoop.idle()
snds.append(_SOUNDFILES[d]) else: return None if aPostfix: snds.append(aPostfix) return soundchain(snds, 1) if __name__ == '__main__': from time import sleep from kivy.base import EventLoop running = True sound.start() s1 = makesoundchain(25, aPrefix='sys\\movement', aPostfix='sys\\percent') if s1: def cb(x): global running running = False s1.callback = cb s1.play() while running: EventLoop.idle() sleep(0.033)
def update_gui(self): if EventLoop.window and hasattr(EventLoop.window, '_mainloop'): EventLoop.window._mainloop() else: EventLoop.idle()
def test_smooth_scroll_end(self): EventLoop.ensure_window() win = EventLoop.window grid = TestGrid() scroll = ScrollView(smooth_scroll_end=10) assert scroll.smooth_scroll_end == 10 scroll.add_widget(grid) # XXX this shouldn't be needed, but previous tests apparently # don't cleanup while win.children: win.remove_widget(win.children[0]) win.add_widget(scroll) # get widgets ready EventLoop.idle() e = scroll.effect_y assert e.velocity == 0 touch = UTMotionEvent("unittest", next(touch_id), { "x": scroll.center_x / float(win.width), "y": scroll.center_y / float(win.height), }) touch.profile.append('button') touch.button = 'scrollup' EventLoop.post_dispatch_input("begin", touch) # EventLoop.post_dispatch_input("update", touch) assert e.velocity == 10 * scroll.scroll_wheel_distance EventLoop.idle() assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance EventLoop.post_dispatch_input("end", touch) EventLoop.idle() assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance # wait for velocity to die off while e.velocity: EventLoop.idle() touch = UTMotionEvent("unittest", next(touch_id), { "x": scroll.center_x / float(win.width), "y": scroll.center_y / float(win.height), }) touch.profile.append('button') touch.button = 'scrolldown' EventLoop.post_dispatch_input("begin", touch) # EventLoop.post_dispatch_input("update", touch) assert e.velocity == -10 * scroll.scroll_wheel_distance EventLoop.idle() assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance EventLoop.post_dispatch_input("end", touch) EventLoop.idle() assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance
def inputhook_myrmidon_kivy(): """The kivy eventloop hook.""" from kivy.base import EventLoop from kivy.utils import platform engine_window = Game.engine['window'] if not engine_window or not engine_window.kivy_app: return 0 kivy_app = engine_window.kivy_app if not kivy_app.built: from kivy.uix.widget import Widget from kivy.core.window import Window from kivy.base import runTouchApp for x in Game._module_list: x._module_setup(cls) kivy_app.load_config() kivy_app.load_kv(filename=kivy_app.kv_file) kivy_app.root = kivy_app.build() if not isinstance(kivy_app.root, Widget): raise Exception('Invalid instance in App.root') Window.add_widget(kivy_app.root) # Check if the window is already created window = EventLoop.window if window: kivy_app._app_window = window window.set_title(kivy_app.get_application_name()) icon = kivy_app.get_application_icon() if icon: window.set_icon(icon) kivy_app._install_settings_keys(window) else: raise Exception("Application: No window is created." " Terminating application run.") kivy_app.dispatch('on_start') runTouchApp(kivy_app.root, slave=True) # Tick forward the Myrmidon event loop one frame Game.app_loop_callback(0) # Tick forward kivy to reflect events and changes from Myrmidon. # This has been directly lifted from `kivy.core.window.window_sdl2`. EventLoop.idle() window = EventLoop.window event = window._win.poll() if event is False or event is None: return 0 action, args = event[0], event[1:] if action == 'quit': EventLoop.quit = True window.close() return 0 elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider # XXX this is problematic. On OSX, it generates touches with 0, # 0 coordinates, at the same times as mouse. But it works. # We have a conflict of using either the mouse or the finger. # Right now, we have no mechanism that we could use to know # which is the preferred one for the application. if platform == "ios": SDL2MotionEventProvider.q.appendleft(event) pass elif action == 'mousemotion': x, y = args x, y = window._fix_mouse_pos(x, y) window._mouse_x = x window._mouse_y = y # don't dispatch motion if no button are pressed if len(window._mouse_buttons_down) == 0: return 0 window._mouse_meta = window.modifiers window.dispatch('on_mouse_move', x, y, window.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args x, y = window._fix_mouse_pos(x, y) btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' window._mouse_buttons_down.add(button) if action == 'mousebuttonup': eventname = 'on_mouse_up' window._mouse_buttons_down.remove(button) window._mouse_x = x window._mouse_y = y window.dispatch(eventname, x, y, btn, window.modifiers) elif action.startswith('mousewheel'): window._update_modifiers() x, y, button = args btn = 'scrolldown' if action.endswith('up'): btn = 'scrollup' elif action.endswith('right'): btn = 'scrollright' elif action.endswith('left'): btn = 'scrollleft' window._mouse_meta = window.modifiers window._mouse_btn = btn #times = x if y == 0 else y #times = min(abs(times), 100) #for k in range(times): window._mouse_down = True window.dispatch('on_mouse_down', window._mouse_x, window._mouse_y, btn, window.modifiers) window._mouse_down = False window.dispatch('on_mouse_up', window._mouse_x, window._mouse_y, btn, window.modifiers) elif action == 'dropfile': dropfile = args window.dispatch('on_dropfile', dropfile[0]) # video resize elif action == 'windowresized': window._size = window._win.window_size # don't use trigger here, we want to delay the resize event cb = window._do_resize from kivy.clock import Clock Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif action == 'windowresized': window.canvas.ask_update() elif action == 'windowrestored': window.canvas.ask_update() elif action == 'windowexposed': window.canvas.ask_update() elif action == 'windowminimized': if Config.getboolean('kivy', 'pause_on_minimize'): window.do_pause() elif action == 'joyaxismotion': stickid, axisid, value = args window.dispatch('on_joy_axis', stickid, axisid, value) elif action == 'joyhatmotion': stickid, hatid, value = args window.dispatch('on_joy_hat', stickid, hatid, value) elif action == 'joyballmotion': stickid, ballid, xrel, yrel = args window.dispatch('on_joy_ball', stickid, ballid, xrel, yrel) elif action == 'joybuttondown': stickid, buttonid = args window.dispatch('on_joy_button_down', stickid, buttonid) elif action == 'joybuttonup': stickid, buttonid = args window.dispatch('on_joy_button_up', stickid, buttonid) elif action in ('keydown', 'keyup'): mod, key, scancode, kstr = args from kivy.core.window import window_sdl2 key_swap = { window_sdl2.SDLK_LEFT: 276, window_sdl2.SDLK_RIGHT: 275, window_sdl2.SDLK_UP: 273, window_sdl2.SDLK_DOWN: 274, window_sdl2.SDLK_HOME: 278, window_sdl2.SDLK_END: 279, window_sdl2.SDLK_PAGEDOWN: 281, window_sdl2.SDLK_PAGEUP: 280, window_sdl2.SDLK_SHIFTR: 303, window_sdl2.SDLK_SHIFTL: 304, window_sdl2.SDLK_SUPER: 309, window_sdl2.SDLK_LCTRL: 305, window_sdl2.SDLK_RCTRL: 306, window_sdl2.SDLK_LALT: 308, window_sdl2.SDLK_RALT: 307, window_sdl2.SDLK_CAPS: 301, window_sdl2.SDLK_INSERT: 277, window_sdl2.SDLK_F1: 282, window_sdl2.SDLK_F2: 283, window_sdl2.SDLK_F3: 284, window_sdl2.SDLK_F4: 285, window_sdl2.SDLK_F5: 286, window_sdl2.SDLK_F6: 287, window_sdl2.SDLK_F7: 288, window_sdl2.SDLK_F8: 289, window_sdl2.SDLK_F9: 290, window_sdl2.SDLK_F10: 291, window_sdl2.SDLK_F11: 292, window_sdl2.SDLK_F12: 293, window_sdl2.SDLK_F13: 294, window_sdl2.SDLK_F14: 295, window_sdl2.SDLK_F15: 296, window_sdl2.SDLK_KEYPADNUM: 300} if platform == 'ios': # XXX ios keyboard suck, when backspace is hit, the delete # keycode is sent. fix it. key_swap[127] = 8 # back try: key = key_swap[key] except KeyError: pass if action == 'keydown': window._update_modifiers(mod, key) else: window._update_modifiers(mod) # ignore the key, it # has been released # if mod in window._meta_keys: if (key not in window._modifiers and key not in window.command_keys.keys()): try: kstr = chr(key) except ValueError: pass #if 'shift' in window._modifiers and key\ # not in window.command_keys.keys(): # return if action == 'keyup': window.dispatch('on_key_up', key, scancode) return 0 # don't dispatch more key if down event is accepted if window.dispatch('on_key_down', key, scancode, kstr, window.modifiers): return 0 window.dispatch('on_keyboard', key, scancode, kstr, window.modifiers) elif action == 'textinput': text = args[0] window.dispatch('on_textinput', text) # XXX on IOS, keydown/up don't send unicode anymore. # With latest sdl, the text is sent over textinput # Right now, redo keydown/up, but we need to seperate both call # too. (and adapt on_key_* API.) #window.dispatch() #window.dispatch('on_key_down', key, None, args[0], # window.modifiers) #window.dispatch('on_keyboard', None, None, args[0], # window.modifiers) #window.dispatch('on_key_up', key, None, args[0], # window.modifiers) # unhandled event ! else: from kivy.logger import Logger Logger.trace('WindowSDL: Unhandled event %s' % str(event)) return 0
def _mainloop(self): EventLoop.idle() for event in pygame.event.get(): # kill application (SIG_TERM) if event.type == pygame.QUIT: if self.dispatch("on_request_close"): continue EventLoop.quit = True self.close() # mouse move elif event.type == pygame.MOUSEMOTION: x, y = event.pos self.mouse_pos = x, self.system_size[1] - y # don't dispatch motion if no button are pressed if event.buttons == (0, 0, 0): continue self._mouse_x = x self._mouse_y = y self._mouse_meta = self.modifiers self.dispatch("on_mouse_move", x, y, self.modifiers) # mouse action elif event.type in (pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): self._pygame_update_modifiers() x, y = event.pos btn = "left" if event.button == 3: btn = "right" elif event.button == 2: btn = "middle" elif event.button == 4: btn = "scrolldown" elif event.button == 5: btn = "scrollup" elif event.button == 6: btn = "scrollright" elif event.button == 7: btn = "scrollleft" eventname = "on_mouse_down" if event.type == pygame.MOUSEBUTTONUP: eventname = "on_mouse_up" self._mouse_x = x self._mouse_y = y self._mouse_meta = self.modifiers self._mouse_btn = btn self._mouse_down = eventname == "on_mouse_down" self.dispatch(eventname, x, y, btn, self.modifiers) # joystick action elif event.type == pygame.JOYAXISMOTION: self.dispatch("on_joy_axis", event.joy, event.axis, event.value) elif event.type == pygame.JOYHATMOTION: self.dispatch("on_joy_hat", event.joy, event.hat, event.value) elif event.type == pygame.JOYBALLMOTION: self.dispatch("on_joy_ball", event.joy, event.ballid, event.rel[0], event.rel[1]) elif event.type == pygame.JOYBUTTONDOWN: self.dispatch("on_joy_button_down", event.joy, event.button) elif event.type == pygame.JOYBUTTONUP: self.dispatch("on_joy_button_up", event.joy, event.button) # keyboard action elif event.type in (pygame.KEYDOWN, pygame.KEYUP): self._pygame_update_modifiers(event.mod) # atm, don't handle keyup if event.type == pygame.KEYUP: self.dispatch("on_key_up", event.key, event.scancode) continue # don't dispatch more key if down event is accepted if self.dispatch("on_key_down", event.key, event.scancode, event.unicode, self.modifiers): continue self.dispatch("on_keyboard", event.key, event.scancode, event.unicode, self.modifiers) # video resize elif event.type == pygame.VIDEORESIZE: self._size = event.size self.update_viewport() elif event.type == pygame.VIDEOEXPOSE: self.canvas.ask_update() # ignored event elif event.type == pygame.ACTIVEEVENT: pass # drop file (pygame patch needed) elif ( event.type == pygame.USEREVENT and hasattr(pygame, "USEREVENT_DROPFILE") and event.code == pygame.USEREVENT_DROPFILE ): self.dispatch("on_dropfile", event.filename) """
def test_smooth_scroll_end(self): EventLoop.ensure_window() win = EventLoop.window grid = _TestGrid() scroll = ScrollView(smooth_scroll_end=10) assert scroll.smooth_scroll_end == 10 scroll.add_widget(grid) # XXX this shouldn't be needed, but previous tests apparently # don't cleanup while win.children: win.remove_widget(win.children[0]) win.add_widget(scroll) # get widgets ready EventLoop.idle() e = scroll.effect_y assert e.velocity == 0 touch = UTMotionEvent( "unittest", next(touch_id), { "x": scroll.center_x / float(win.width), "y": scroll.center_y / float(win.height), }) touch.profile.append('button') touch.button = 'scrollup' EventLoop.post_dispatch_input("begin", touch) # EventLoop.post_dispatch_input("update", touch) assert e.velocity == 10 * scroll.scroll_wheel_distance EventLoop.idle() assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance EventLoop.post_dispatch_input("end", touch) EventLoop.idle() assert 0 < e.velocity < 10 * scroll.scroll_wheel_distance # wait for velocity to die off while e.velocity: EventLoop.idle() touch = UTMotionEvent( "unittest", next(touch_id), { "x": scroll.center_x / float(win.width), "y": scroll.center_y / float(win.height), }) touch.profile.append('button') touch.button = 'scrolldown' EventLoop.post_dispatch_input("begin", touch) # EventLoop.post_dispatch_input("update", touch) assert e.velocity == -10 * scroll.scroll_wheel_distance EventLoop.idle() assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance EventLoop.post_dispatch_input("end", touch) EventLoop.idle() assert 0 > e.velocity > -10 * scroll.scroll_wheel_distance
def _mainloop(self): EventLoop.idle() for event in pygame.event.get(): # kill application (SIG_TERM) if event.type == pygame.QUIT: EventLoop.quit = True self.close() # mouse move elif event.type == pygame.MOUSEMOTION: # don't dispatch motion if no button are pressed if event.buttons == (0, 0, 0): continue x, y = event.pos self.dispatch('on_mouse_move', x, y, self.modifiers) # mouse action elif event.type in (pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): self._pygame_update_modifiers() x, y = event.pos btn = 'left' if event.button == 3: btn = 'right' elif event.button == 2: btn = 'middle' elif event.button == 4: btn = 'scrolldown' elif event.button == 5: btn = 'scrollup' eventname = 'on_mouse_down' if event.type == pygame.MOUSEBUTTONUP: eventname = 'on_mouse_up' self.dispatch(eventname, x, y, btn, self.modifiers) # keyboard action elif event.type in (pygame.KEYDOWN, pygame.KEYUP): self._pygame_update_modifiers(event.mod) # atm, don't handle keyup if event.type == pygame.KEYUP: self.dispatch('on_key_up', event.key, event.scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', event.key, event.scancode, event.unicode, self.modifiers): continue self.dispatch('on_keyboard', event.key, event.scancode, event.unicode, self.modifiers) # video resize elif event.type == pygame.VIDEORESIZE: self._size = event.size # don't use trigger here, we want to delay the resize event cb = self._do_resize Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif event.type == pygame.VIDEOEXPOSE: self.canvas.ask_update() # ignored event elif event.type == pygame.ACTIVEEVENT: pass '''
def _mainloop(self): EventLoop.idle() while True: event = sdl.poll() if event is False: break if event is None: continue #print 'sdl received', event action, args = event[0], event[1:] if action == 'quit': EventLoop.quit = True self.close() break elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider SDLMotionEventProvider.q.appendleft(event) if action == 'mousemotion': x, y = args self.dispatch('on_mouse_move', x, y, self.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' if action == 'mousebuttonup': eventname = 'on_mouse_up' self.dispatch(eventname, x, y, btn, self.modifiers) # video resize elif action == 'windowresized': self._size = args # don't use trigger here, we want to delay the resize event cb = self._do_resize Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif action == 'windowresized': self.canvas.ask_update() elif action == 'windowminimized': self.do_pause() elif action == 'windowrestored': pass elif action in ('keydown', 'keyup'): mod, key, scancode, unicode = args # XXX ios keyboard suck, when backspace is hit, the delete # keycode is sent. fix it. if key == 127: key = 8 self._pygame_update_modifiers(mod) if action == 'keyup': self.dispatch('on_key_up', key, scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', key, scancode, unicode, self.modifiers): continue self.dispatch('on_keyboard', key, scancode, unicode, self.modifiers) elif action == 'textinput': key = args[0][0] # XXX on IOS, keydown/up don't send unicode anymore. # With latest sdl, the text is sent over textinput # Right now, redo keydown/up, but we need to seperate both call # too. (and adapt on_key_* API.) self.dispatch('on_key_down', key, None, args[0], self.modifiers) self.dispatch('on_keyboard', None, None, args[0], self.modifiers) self.dispatch('on_key_up', key, None, args[0], self.modifiers)
def generation_step(self, with_realize = False): "Will be called in order to show some advancement" i, row, col, face, item = self.index.pop() #Determine wheter a new page should be appended face_index = 0 if self.current_face == 'F' else 1 if self.current_face != face: self.current_face = face self.current_page_num[1-face_index] = i self.AddPage() elif self.current_page_num[face_index] != i: self.current_page_num[face_index] = i self.AddPage() #Determine Image X/Y/W/H depending on print mode if self.mode == 'LAYOUT': x, y, self.x, self.y, angle, pageindex = item.layout x /= cm(1) y /= cm(1) self.x /= cm(1) self.y /= cm(1) elif self.mode == 'BINCAN': x, y, self.x, self.y, angle, item = item #hackick: replace item in place ! x /= cm(1) y /= cm(1) self.x /= cm(1) self.y /= cm(1) else: if face == 'F': x, y = col * self.x + left, height-(1+row)*self.y - top else: x, y = width - (1+col)*self.x - left - right, height-(1+row)*self.y - top #x, y = width - (1+col)*self.x - right, height-(1+row)*self.y - top #self.x & slef.y has already been setp by calculate_size #Check is there is a layout that could be used, just for the angle if getattr(item, 'layout',0): angle = item.layout[4] else: angle = 0 #Now that in item lies the Stack Item, before rendering it, inject special print vairables item.print_index = { 'pagenum' : i, 'stackrow': row, 'stackcol': col, 'pageface': face } # Now, define source for image: we either get the source or convert to image if item.image:#speicla case for complex image manip src = ImageReader(item.image.rotate(angle)) elif item.template: if with_realize: item.realise(True,True) tmplWidget = item.tmplWidget elif item.tmplWidget:#it has been modified tmplWidget = item.tmplWidget else: from template import BGTemplate Logger.info( '[Printer] Generation Step without tmplWidget') tmplWidget = BGTemplate.FromFile(item.template) if tmplWidget: #only taking the last one tmplWidget = tmplWidget[-1] else: raise NameError('No such template: '+ item.template) if item.values: tmplWidget.apply_values(item.values) from kivy.base import EventLoop EventLoop.idle() cim = tmplWidget.toImage(for_print=True) pim = frombuffer('RGBA', cim.size, cim._texture.pixels, 'raw', 'RGBA',0,1) src = ImageReader(pim.rotate(angle)) else: src = item.source from utils import find_path src = find_path(src) if angle: src = ImageReader(PILOpen(src).rotate(angle)) #print "Adding Image to pdf", i, row, col, face, item, src, x, y, self.x, self.y, angle self.pdf.drawImage(src, x*r_cm, y*r_cm, self.x*r_cm, self.y*r_cm, mask='auto') from conf import CP if CP.getboolean('Print','draw_cut_rect'): #add line after image: they ll be above self.AddLines(x,y,self.x,self.y)
def _mainloop(self): EventLoop.idle() # for android/iOS, we don't want to have any event nor executing our # main loop while the pause is going on. This loop wait any event (not # handled by the event filter), and remove them from the queue. # Nothing happen during the pause on iOS, except gyroscope value sended # over joystick. So it's safe. while self._pause_loop: self._win.wait_event() if not self._pause_loop: break self._win.poll() while True: event = self._win.poll() if event is False: break if event is None: continue action, args = event[0], event[1:] if action == 'quit': if self.dispatch('on_request_close'): continue EventLoop.quit = True self.close() break elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider # XXX this is problematic. On OSX, it generates touches with 0, # 0 coordinates, at the same times as mouse. But it works. # We have a conflict of using either the mouse or the finger. # Right now, we have no mechanism that we could use to know # which is the preferred one for the application. if platform in ('ios', 'android'): SDL2MotionEventProvider.q.appendleft(event) pass elif action == 'mousemotion': x, y = args x, y = self._fix_mouse_pos(x, y) self._mouse_x = x self._mouse_y = y # don't dispatch motion if no button are pressed if len(self._mouse_buttons_down) == 0: continue self._mouse_meta = self.modifiers self.dispatch('on_mouse_move', x, y, self.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args x, y = self._fix_mouse_pos(x, y) btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' self._mouse_buttons_down.add(button) if action == 'mousebuttonup': eventname = 'on_mouse_up' self._mouse_buttons_down.remove(button) self._mouse_x = x self._mouse_y = y self.dispatch(eventname, x, y, btn, self.modifiers) elif action.startswith('mousewheel'): self._update_modifiers() x, y, button = args btn = 'scrolldown' if action.endswith('up'): btn = 'scrollup' elif action.endswith('right'): btn = 'scrollright' elif action.endswith('left'): btn = 'scrollleft' self._mouse_meta = self.modifiers self._mouse_btn = btn #times = x if y == 0 else y #times = min(abs(times), 100) #for k in range(times): self._mouse_down = True self.dispatch('on_mouse_down', self._mouse_x, self._mouse_y, btn, self.modifiers) self._mouse_down = False self.dispatch('on_mouse_up', self._mouse_x, self._mouse_y, btn, self.modifiers) elif action == 'dropfile': dropfile = args self.dispatch('on_dropfile', dropfile[0]) # video resize elif action == 'windowresized': self._size = self._win.window_size # don't use trigger here, we want to delay the resize event cb = self._do_resize Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif action == 'windowresized': self.canvas.ask_update() elif action == 'windowrestored': self.canvas.ask_update() elif action == 'windowexposed': self.canvas.ask_update() elif action == 'windowminimized': if Config.getboolean('kivy', 'pause_on_minimize'): self.do_pause() elif action == 'joyaxismotion': stickid, axisid, value = args self.dispatch('on_joy_axis', stickid, axisid, value) elif action == 'joyhatmotion': stickid, hatid, value = args self.dispatch('on_joy_hat', stickid, hatid, value) elif action == 'joyballmotion': stickid, ballid, xrel, yrel = args self.dispatch('on_joy_ball', stickid, ballid, xrel, yrel) elif action == 'joybuttondown': stickid, buttonid = args self.dispatch('on_joy_button_down', stickid, buttonid) elif action == 'joybuttonup': stickid, buttonid = args self.dispatch('on_joy_button_up', stickid, buttonid) elif action in ('keydown', 'keyup'): mod, key, scancode, kstr = args key_swap = { SDLK_LEFT: 276, SDLK_RIGHT: 275, SDLK_UP: 273, SDLK_DOWN: 274, SDLK_HOME: 278, SDLK_END: 279, SDLK_PAGEDOWN: 281, SDLK_PAGEUP: 280, SDLK_SHIFTR: 303, SDLK_SHIFTL: 304, SDLK_SUPER: 309, SDLK_LCTRL: 305, SDLK_RCTRL: 306, SDLK_LALT: 308, SDLK_RALT: 307, SDLK_CAPS: 301, SDLK_INSERT: 277, SDLK_F1: 282, SDLK_F2: 283, SDLK_F3: 284, SDLK_F4: 285, SDLK_F5: 286, SDLK_F6: 287, SDLK_F7: 288, SDLK_F8: 289, SDLK_F9: 290, SDLK_F10: 291, SDLK_F11: 292, SDLK_F12: 293, SDLK_F13: 294, SDLK_F14: 295, SDLK_F15: 296, SDLK_KEYPADNUM: 300, SDLK_KP_DEVIDE: 267, SDLK_KP_MULTIPLY: 268, SDLK_KP_MINUS: 269, SDLK_KP_PLUS: 270, SDLK_KP_ENTER: 271, SDLK_KP_DOT: 266, SDLK_KP_0: 256, SDLK_KP_1: 257, SDLK_KP_2: 258, SDLK_KP_3: 259, SDLK_KP_4: 260, SDLK_KP_5: 261, SDLK_KP_6: 262, SDLK_KP_7: 263, SDLK_KP_8: 264, SDLK_KP_9: 265 } if platform == 'ios': # XXX ios keyboard suck, when backspace is hit, the delete # keycode is sent. fix it. key_swap[127] = 8 # back try: key = key_swap[key] except KeyError: pass if action == 'keydown': self._update_modifiers(mod, key) else: self._update_modifiers(mod) # ignore the key, it # has been released # if mod in self._meta_keys: if (key not in self._modifiers and key not in self.command_keys.keys()): try: kstr = unichr(key) except ValueError: pass #if 'shift' in self._modifiers and key\ # not in self.command_keys.keys(): # return if action == 'keyup': self.dispatch('on_key_up', key, scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', key, scancode, kstr, self.modifiers): continue self.dispatch('on_keyboard', key, scancode, kstr, self.modifiers) elif action == 'textinput': text = args[0] self.dispatch('on_textinput', text) # unhandled event ! else: Logger.trace('WindowSDL: Unhandled event %s' % str(event))
def move_frames(self, t): for i in range(t): EventLoop.idle()
def _run_mc(self, dt): del dt if self.unittest_verbosity() > 1: time.sleep(.05) EventLoop.idle()
def _mainloop(self): EventLoop.idle() for event in pygame.event.get(): # kill application (SIG_TERM) if event.type == pygame.QUIT: EventLoop.quit = True self.close() # mouse move elif event.type == pygame.MOUSEMOTION: x, y = event.pos self.mouse_pos = x, self.system_size[1] - y # don't dispatch motion if no button are pressed if event.buttons == (0, 0, 0): continue self._mouse_x = x self._mouse_y = y self._mouse_meta = self.modifiers self.dispatch('on_mouse_move', x, y, self.modifiers) # mouse action elif event.type in (pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): self._pygame_update_modifiers() x, y = event.pos btn = 'left' if event.button == 3: btn = 'right' elif event.button == 2: btn = 'middle' elif event.button == 4: btn = 'scrolldown' elif event.button == 5: btn = 'scrollup' elif event.button == 6: btn = 'scrollright' elif event.button == 7: btn = 'scrollleft' eventname = 'on_mouse_down' if event.type == pygame.MOUSEBUTTONUP: eventname = 'on_mouse_up' self._mouse_x = x self._mouse_y = y self._mouse_meta = self.modifiers self._mouse_btn = btn self._mouse_down = eventname == 'on_mouse_down' self.dispatch(eventname, x, y, btn, self.modifiers) # keyboard action elif event.type in (pygame.KEYDOWN, pygame.KEYUP): self._pygame_update_modifiers(event.mod) # atm, don't handle keyup if event.type == pygame.KEYUP: self.dispatch('on_key_up', event.key, event.scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', event.key, event.scancode, event.unicode, self.modifiers): continue self.dispatch('on_keyboard', event.key, event.scancode, event.unicode, self.modifiers) # video resize elif event.type == pygame.VIDEORESIZE: self._size = event.size self.update_viewport() elif event.type == pygame.VIDEOEXPOSE: self.canvas.ask_update() # ignored event elif event.type == pygame.ACTIVEEVENT: pass # drop file (pygame patch needed) elif event.type == pygame.USEREVENT and \ hasattr(pygame, 'USEREVENT_DROPFILE') and \ event.code == pygame.USEREVENT_DROPFILE: self.dispatch('on_dropfile', event.filename) '''
def _mainloop(self): EventLoop.idle() # for android/iOS, we don't want to have any event nor executing our # main loop while the pause is going on. This loop wait any event (not # handled by the event filter), and remove them from the queue. # Nothing happen during the pause on iOS, except gyroscope value sent # over joystick. So it's safe. while self._pause_loop: self._win.wait_event() if not self._pause_loop: break self._win.poll() while True: event = self._win.poll() if event is False: break if event is None: continue action, args = event[0], event[1:] if action == 'quit': if self.dispatch('on_request_close'): continue EventLoop.quit = True self.close() break elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider # XXX this is problematic. On OSX, it generates touches with 0, # 0 coordinates, at the same times as mouse. But it works. # We have a conflict of using either the mouse or the finger. # Right now, we have no mechanism that we could use to know # which is the preferred one for the application. if platform in ('ios', 'android'): SDL2MotionEventProvider.q.appendleft(event) pass elif action == 'mousemotion': x, y = args x, y = self._fix_mouse_pos(x, y) self._mouse_x = x self._mouse_y = y # don't dispatch motion if no button are pressed if len(self._mouse_buttons_down) == 0: continue self._mouse_meta = self.modifiers self.dispatch('on_mouse_move', x, y, self.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args x, y = self._fix_mouse_pos(x, y) btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' self._mouse_buttons_down.add(button) if action == 'mousebuttonup': eventname = 'on_mouse_up' self._mouse_buttons_down.remove(button) self._mouse_x = x self._mouse_y = y self.dispatch(eventname, x, y, btn, self.modifiers) elif action.startswith('mousewheel'): self._update_modifiers() x, y, button = args btn = 'scrolldown' if action.endswith('up'): btn = 'scrollup' elif action.endswith('right'): btn = 'scrollright' elif action.endswith('left'): btn = 'scrollleft' self._mouse_meta = self.modifiers self._mouse_btn = btn #times = x if y == 0 else y #times = min(abs(times), 100) #for k in range(times): self._mouse_down = True self.dispatch('on_mouse_down', self._mouse_x, self._mouse_y, btn, self.modifiers) self._mouse_down = False self.dispatch('on_mouse_up', self._mouse_x, self._mouse_y, btn, self.modifiers) elif action == 'dropfile': dropfile = args self.dispatch('on_dropfile', dropfile[0]) # video resize elif action == 'windowresized': self._size = self._win.window_size # don't use trigger here, we want to delay the resize event ev = self._do_resize_ev if ev is None: ev = self._do_resize_ev = Clock.schedule_once(self._do_resize, .1) else: ev() elif action == 'windowresized': self.canvas.ask_update() elif action == 'windowrestored': self.dispatch('on_restore') self.canvas.ask_update() elif action == 'windowexposed': self.canvas.ask_update() elif action == 'windowminimized': self.dispatch('on_minimize') if Config.getboolean('kivy', 'pause_on_minimize'): self.do_pause() elif action == 'windowmaximized': self.dispatch('on_maximize') elif action == 'windowhidden': self.dispatch('on_hide') elif action == 'windowshown': self.dispatch('on_show') elif action == 'windowfocusgained': self._focus = True elif action == 'windowfocuslost': self._focus = False elif action == 'windowenter': self.dispatch('on_cursor_enter') elif action == 'windowleave': self.dispatch('on_cursor_leave') elif action == 'joyaxismotion': stickid, axisid, value = args self.dispatch('on_joy_axis', stickid, axisid, value) elif action == 'joyhatmotion': stickid, hatid, value = args self.dispatch('on_joy_hat', stickid, hatid, value) elif action == 'joyballmotion': stickid, ballid, xrel, yrel = args self.dispatch('on_joy_ball', stickid, ballid, xrel, yrel) elif action == 'joybuttondown': stickid, buttonid = args self.dispatch('on_joy_button_down', stickid, buttonid) elif action == 'joybuttonup': stickid, buttonid = args self.dispatch('on_joy_button_up', stickid, buttonid) elif action in ('keydown', 'keyup'): mod, key, scancode, kstr = args try: key = self.key_map[key] except KeyError: pass if action == 'keydown': self._update_modifiers(mod, key) else: self._update_modifiers(mod) # ignore the key, it # has been released # if mod in self._meta_keys: if (key not in self._modifiers and key not in self.command_keys.keys()): try: kstr = unichr(key) except ValueError: pass #if 'shift' in self._modifiers and key\ # not in self.command_keys.keys(): # return if action == 'keyup': self.dispatch('on_key_up', key, scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', key, scancode, kstr, self.modifiers): continue self.dispatch('on_keyboard', key, scancode, kstr, self.modifiers) elif action == 'textinput': text = args[0] self.dispatch('on_textinput', text) # unhandled event ! else: Logger.trace('WindowSDL: Unhandled event %s' % str(event))
def _mainloop(self): EventLoop.idle() while True: event = self._win.poll() if event is False: break if event is None: continue action, args = event[0], event[1:] if action == 'quit': EventLoop.quit = True self.close() break elif action in ('fingermotion', 'fingerdown', 'fingerup'): # for finger, pass the raw event to SDL motion event provider SDL2MotionEventProvider.q.appendleft(event) if action == 'mousemotion': x, y = args self.mouse_pos = x, self.system_size[1] - y # don't dispatch motion if no button are pressed self._mouse_x = x self._mouse_y = y self._mouse_meta = self.modifiers self.dispatch('on_mouse_move', x, y, self.modifiers) elif action in ('mousebuttondown', 'mousebuttonup'): x, y, button = args btn = 'left' if button == 3: btn = 'right' elif button == 2: btn = 'middle' eventname = 'on_mouse_down' if action == 'mousebuttonup': eventname = 'on_mouse_up' self.dispatch(eventname, x, y, btn, self.modifiers) elif action.startswith('mousewheel'): self._update_modifiers() x, y, button = args btn = 'scrolldown' if action.endswith('up'): btn = 'scrollup' elif action.endswith('right'): btn = 'scrollright' elif action.endswith('left'): btn = 'scrollleft' self._mouse_meta = self.modifiers self._mouse_btn = btn #times = x if y == 0 else y #times = min(abs(times), 100) #for k in range(times): self._mouse_down = True self.dispatch('on_mouse_down', self._mouse_x, self._mouse_y, btn, self.modifiers) self._mouse_down = False self.dispatch('on_mouse_up', self._mouse_x, self._mouse_y, btn, self.modifiers) elif action == 'dropfile': dropfile = args self.dispatch('on_dropfile', dropfile[0]) # video resize elif action == 'windowresized': self._size = args # don't use trigger here, we want to delay the resize event cb = self._do_resize Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif action == 'windowresized': self.canvas.ask_update() elif action == 'windowrestored': self.canvas.ask_update() elif action == 'windowminimized': self.do_pause() elif action == 'joyaxismotion': stickid, axisid, value = args self.dispatch('on_joy_axis', stickid, axisid, value) elif action == 'joyhatmotion': stickid, hatid, value = args self.dispatch('on_joy_hat', stickid, hatid, value) elif action == 'joyballmotion': stickid, ballid, xrel, yrel = args self.dispatch('on_joy_ball', stickid, ballid, xrel, yrel) elif action == 'joybuttondown': stickid, buttonid = args self.dispatch('on_joy_button_down', stickid, buttonid) elif action == 'joybuttonup': stickid, buttonid = args self.dispatch('on_joy_button_up', stickid, buttonid) elif action in ('keydown', 'keyup'): mod, key, scancode, kstr = args if mod in self._meta_keys: try: kstr = unichr(key) except ValueError: pass # XXX ios keyboard suck, when backspace is hit, the delete # keycode is sent. fix it. key_swap = {127: 8, # back SDLK_LEFT: 276, SDLK_RIGHT: 275, SDLK_UP: 273, SDLK_DOWN: 274, SDLK_HOME: 278, SDLK_END: 279, SDLK_PAGEDOWN: 281, SDLK_PAGEUP: 280, SDLK_SHIFTL: 303, SDLK_SHIFTR: 304} try: key = key_swap[key] except KeyError: pass self._update_modifiers(mod) if action == 'keyup': self.dispatch('on_key_up', key, scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', key, scancode, kstr, self.modifiers): continue self.dispatch('on_keyboard', key, scancode, kstr, self.modifiers) elif action == 'textinput': key = args[0][0] # XXX on IOS, keydown/up don't send unicode anymore. # With latest sdl, the text is sent over textinput # Right now, redo keydown/up, but we need to seperate both call # too. (and adapt on_key_* API.) self.dispatch('on_key_down', key, None, args[0], self.modifiers) self.dispatch('on_keyboard', None, None, args[0], self.modifiers) self.dispatch('on_key_up', key, None, args[0], self.modifiers)
def inner(*args): from kivy.base import EventLoop EventLoop.idle() cim = tmpl.toImage() cim.texture.flip_vertical() self.ids['img'].texture = cim.texture
def test_touch_draw(self): # get Window instance for creating visible # widget tree and for calculating coordinates EventLoop.ensure_window() win = EventLoop.window # add widget for testing child = WidgetCanvasDraw() win.add_widget(child) # get widgets ready EventLoop.idle() # default "cursor" position in the middle pos = [win.width / 2.0, win.height / 2.0] # default pos, new pos points = [ [pos[0] - 5, pos[1], pos[0] + 5, pos[1]], [pos[0], pos[1] - 5, pos[0], pos[1] + 5] ] # general behavior for touch+move+release for i, point in enumerate(points): x, y, nx, ny = point # create custom MotionEvent (touch) instance touch = UTMotionEvent("unittest", 1, { "sx": x / float(win.width), "sy": y / float(win.height), }) # dispatch the MotionEvent in EventLoop as # touch/press/click, see Profiles for more info: # https://kivy.org/docs/api-kivy.input.motionevent.html#profiles EventLoop.post_dispatch_input("begin", touch) # the touch is dispatched and has ud['lines'] # available from on_touch_down self.assertIn('lines', touch.ud) self.assertTrue(isinstance(touch.ud['lines'], Point)) # move touch from current to the new position touch.move({ "sx": nx / float(win.width), "sy": ny / float(win.height) }) # update the MotionEvent in EventLoop EventLoop.post_dispatch_input("update", touch) # release the MotionEvent in EventLoop EventLoop.post_dispatch_input("end", touch) # still available, but released self.assertIn('lines', touch.ud) self.assertTrue(isinstance(touch.ud['lines'], Point)) expected_points = [[ x + 0, y, x + 1, y, x + 2, y, x + 3, y, x + 4, y, x + 5, y, x + 6, y, x + 7, y, x + 8, y, x + 9, y ], [ x, y + 0, x, y + 1, x, y + 2, x, y + 3, x, y + 4, x, y + 5, x, y + 6, x, y + 7, x, y + 8, x, y + 9 ]] # check if the instruction points == expected ones self.assertEqual( touch.ud['lines'].points, expected_points[i] ) # render the graphics self.render(child)
def magic_fill(self): #alas, I have to linezarise in order to save layout for each widget from kivy.app import App from kivy.base import EventLoop from kivy.uix.label import Label from utils import alert print 'linearize deck', alert('Linearizing Deck') EventLoop.idle() App.get_running_app().root.ids.deck.linearize(progressbar=self.ids.progress) print 'done' init_pi = self.page_index from conf import page_format SIZE = page_format.width-page_format.left-page_format.right, page_format.height-page_format.top-page_format.bottom print 'calculating stack size' alert('Calculating Size') EventLoop.idle() #first create tuple of fg/bg fg,bg,dual_dict = self.get_duals() #fill current page with what you can def skey(item): w,h = item[0].stack.getSize() return w*h, -item[1] self.ids.progress.max = len(fg) self.ids.progress.value = 1 from kivy.clock import Clock alert('Sorting Layouts by size') EventLoop.idle() print 'sorting layout' fg = sorted(fg, key=skey, reverse=True) def inner(*args): from utils import alert if not fg: Clock.unschedule(inner) from utils import alert alert('Book created') self.export_phs() from kivy.uix.widget import WidgetException try: self.set_page("Page %d"%(init_pi+1)) except WidgetException,Err: print 'FATAL: Error in Setting page ???',Err return alert('Organizing Layout on Page %d'%(len(self.pages))) EventLoop.idle() print 'Organizing Layout on Page %d'%(len(self.pages)) sorted_phs = fg[:] added_ones = list() PAGE_LAYOUT = BinCanNode(0, 0, SIZE[0], SIZE[1]) for f, i in sorted_phs: layout = PAGE_LAYOUT.find(f, *f.stack.getSize()) if not layout: continue del fg[fg.index((f, i))] added_ones.append(f) self.ids.progress.value += 1 ph = self.add_ph() self.set_ph_img(ph, f, use_img_size= True) X, Y = layout.x, layout.y #Rebase properly ph.x = X + page_format.left ph.top = page_format.height-page_format.top-Y ph.angle = layout.retry.get(ph, 0) * 90 ph.layout = [ph.x,ph.y,ph.width,ph.height,ph.angle, self.page_index] if not added_ones: #We could NOT feet any of the pictures: raise error: print 'Error: not pictures could be fit inside one page' from utils import alert alert('No more pictures can fit on page') Clock.unschedule(inner) return if dual_dict: #First page is done, create dual mp = self.add_mirror_page() for ph, b in zip (reversed(mp.children), [dual_dict[f] for f in added_ones]): #print 'settings back for', ph, b, b.stack.source self.set_ph_img(ph,b, use_img_size= False) # Is it interesting: this will force that front & back have exact same size, depending on front size #Add a new page, only if necessay: if fg: self.add_page() #now loop on remaining fg/bg Clock.schedule_once(inner,.1)
def test_slider_move(self): EventLoop.ensure_window() win = EventLoop.window layout = BoxLayout(orientation='vertical') s_handle = TestSliderHandle() s_all = TestSliderAll() layout.add_widget(s_handle) layout.add_widget(s_all) win.add_widget(layout) # get widgets ready EventLoop.idle() cur1 = s_handle.children[0] cur2 = s_all.children[0] h1 = cur1.to_window(*cur1.center)[1] h2 = h1 - s_handle.cursor_height h3 = cur2.to_window(*cur2.center)[1] h4 = h3 - s_all.cursor_height w1 = cur1.to_window(*cur1.center)[0] w2 = cur2.to_window(*cur2.center)[0] wh = win.width / 2.0 dt = 2 # default pos, new pos, slider ID points = [ [w1, h1, wh, h1, 'handle'], [w1, h2, wh, h2, 'handle'], [w2, h3, wh, h3, 'all'], [w2, h4, wh, h4, 'all'], ] for point in points: x, y, nx, ny, id = point # custom touch touch = UTMotionEvent("unittest", 1, { "x": x / float(win.width), "y": y / float(win.height), }) # touch down EventLoop.post_dispatch_input("begin", touch) if id == 'handle': # touch on handle if x == w1 and y == h1: self.assertAlmostEqual( s_handle.value, 0.0, delta=dt ) # touch in widget area (ignored, previous value) elif x == w1 and y == h2: self.assertAlmostEqual( s_handle.value, 50.0, delta=dt ) elif id == 'all': # touch on handle: if x == w1 and y == h3: self.assertAlmostEqual( s_all.value, 0.0, delta=dt ) # touch in widget area elif x == w1 and y == h4: self.assertAlmostEqual( s_all.value, 0.0, delta=dt ) # move from default to new pos touch.move({ "x": nx / float(win.width), "y": ny / float(win.height) }) EventLoop.post_dispatch_input("update", touch) if id == 'handle': # move from handle to center if nx == wh and ny == h1: self.assertAlmostEqual( s_handle.value, 50.0, delta=dt ) # move to center (ignored, previous value) elif nx == wh and ny == h2: self.assertAlmostEqual( s_handle.value, 50.0, delta=dt ) elif id == 'all': # touch on handle: if nx == wh and ny == h3: self.assertAlmostEqual( s_all.value, 50.0, delta=dt ) # touch in widget area elif nx == wh and ny == h4: self.assertAlmostEqual( s_all.value, 50.0, delta=dt ) # touch up EventLoop.post_dispatch_input("end", touch) self.render(layout)
def magic_fill(self): #alas, I have to linezarise in order to save layout for each widget from kivy.app import App from kivy.base import EventLoop from kivy.uix.label import Label from utils import alert print 'linearize deck', alert('Linearizing Deck') EventLoop.idle() App.get_running_app().root.ids.deck.linearize( progressbar=self.ids.progress) print 'done' init_pi = self.page_index from conf import page_format SIZE = page_format.width - page_format.left - page_format.right, page_format.height - page_format.top - page_format.bottom print 'calculating stack size' alert('Calculating Size') EventLoop.idle() #first create tuple of fg/bg fg, bg, dual_dict = self.get_duals() #fill current page with what you can def skey(item): w, h = item[0].stack.getSize() return w * h, -item[1] self.ids.progress.max = len(fg) self.ids.progress.value = 1 from kivy.clock import Clock alert('Sorting Layouts by size') EventLoop.idle() print 'sorting layout' fg = sorted(fg, key=skey, reverse=True) def inner(*args): from utils import alert if not fg: Clock.unschedule(inner) from utils import alert alert('Book created') self.export_phs() from kivy.uix.widget import WidgetException try: self.set_page("Page %d" % (init_pi + 1)) except WidgetException, Err: print 'FATAL: Error in Setting page ???', Err return alert('Organizing Layout on Page %d' % (len(self.pages))) EventLoop.idle() print 'Organizing Layout on Page %d' % (len(self.pages)) sorted_phs = fg[:] added_ones = list() PAGE_LAYOUT = BinCanNode(0, 0, SIZE[0], SIZE[1]) for f, i in sorted_phs: layout = PAGE_LAYOUT.find(f, *f.stack.getSize()) if not layout: continue del fg[fg.index((f, i))] added_ones.append(f) self.ids.progress.value += 1 ph = self.add_ph() self.set_ph_img(ph, f, use_img_size=True) X, Y = layout.x, layout.y #Rebase properly ph.x = X + page_format.left ph.top = page_format.height - page_format.top - Y ph.angle = layout.retry.get(ph, 0) * 90 ph.layout = [ ph.x, ph.y, ph.width, ph.height, ph.angle, self.page_index ] if not added_ones: #We could NOT feet any of the pictures: raise error: print 'Error: not pictures could be fit inside one page' from utils import alert alert('No more pictures can fit on page') Clock.unschedule(inner) return if dual_dict: #First page is done, create dual mp = self.add_mirror_page() for ph, b in zip(reversed(mp.children), [dual_dict[f] for f in added_ones]): #print 'settings back for', ph, b, b.stack.source self.set_ph_img( ph, b, use_img_size=False ) # Is it interesting: this will force that front & back have exact same size, depending on front size #Add a new page, only if necessay: if fg: self.add_page() #now loop on remaining fg/bg Clock.schedule_once(inner, .1)
def _run_mc(self): EventLoop.idle()
def _mainloop(self): EventLoop.idle() for event in pygame.event.get(): # kill application (SIG_TERM) if event.type == pygame.QUIT: EventLoop.quit = True self.close() # mouse move elif event.type == pygame.MOUSEMOTION: # don't dispatch motion if no button are pressed if event.buttons == (0, 0, 0): continue x, y = event.pos self.dispatch('on_mouse_move', x, y, self.modifiers) # mouse action elif event.type in (pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP): self._pygame_update_modifiers() x, y = event.pos btn = 'left' if event.button == 3: btn = 'right' elif event.button == 2: btn = 'middle' eventname = 'on_mouse_down' if event.type == pygame.MOUSEBUTTONUP: eventname = 'on_mouse_up' self.dispatch(eventname, x, y, btn, self.modifiers) # keyboard action elif event.type in (pygame.KEYDOWN, pygame.KEYUP): self._pygame_update_modifiers(event.mod) # atm, don't handle keyup if event.type == pygame.KEYUP: self.dispatch('on_key_up', event.key, event.scancode) continue # don't dispatch more key if down event is accepted if self.dispatch('on_key_down', event.key, event.scancode, event.unicode, event.mod): continue self.dispatch('on_keyboard', event.key, event.scancode, event.unicode, event.mod) # video resize elif event.type == pygame.VIDEORESIZE: self._size = event.size # don't use trigger here, we want to delay the resize event cb = self._do_resize Clock.unschedule(cb) Clock.schedule_once(cb, .1) elif event.type == pygame.VIDEOEXPOSE: self.canvas.ask_update() # ignored event elif event.type == pygame.ACTIVEEVENT: pass # unhandled event ! else: Logger.debug('WinPygame: Unhandled event %s' % str(event))