def prepare_response_func(self): """See base_response_item.""" self._keyboard = keyboard(self.experiment, timeout=self._timeout, keylist=self._allowed_responses) return self._keyboard.get_key
def prepare_response_func(self): """See base_response_item.""" self._keyboard = keyboard(self.experiment, keylist=self._allowed_responses, timeout=self._timeout) if self.var._dummy == u'yes': return self._keyboard.get_key # Prepare the device string dev = self.var.dev if dev == u"autodetect": dev = None # Dynamically create an srbox instance if not hasattr(self.experiment, "srbox"): self.experiment.srbox = libsrbox.libsrbox(self.experiment, dev) self.experiment.cleanup_functions.append(self.close) self.python_workspace[u'srbox'] = self.experiment.srbox # Prepare the light byte s = "010" # Control string for i in range(5): if str(5 - i) in str(self.var.lights): s += "1" else: s += "0" self._lights = chr(int(s, 2)) debug.msg(u"lights string set to %s (%s)" % (s, self.var.lights)) if self._allowed_responses is not None: self._allowed_responses = [int(r) for r in self._allowed_responses] self._require_state_change = self.var.require_state_change == u'yes' return self._get_button_press
def __init__(self, experiment, src): """<DOC> Initializes the sampler with a specified file. Arguments: experiment -- An instance of libopensesame.experiment.experiment. src -- A path to a .wav or .ogg file. Example: >>> from openexp.sampler import sampler >>> src = exp.get_file('my_sound.ogg') >>> my_sampler = sampler(exp, src) </DOC>""" if src != None: if not os.path.exists(src): raise osexception(u"openexp._sampler.legacy.__init__() the file '%s' does not exist" % src) if os.path.splitext(src)[1].lower() not in (".ogg", ".wav"): raise osexception(u"openexp._sampler.legacy.__init__() the file '%s' is not an .ogg or .wav file" % src) self.sound = mixer.Sound(src) self.experiment = experiment self.keyboard = keyboard(experiment) self._stop_after = 0 self._fade_in = 0 self._volume = 1.0
def __init__(self, experiment, tracker): """ Constructor Arguments: experiment -- opensesame experiment tracker -- an eyelink instance """ pylink.EyeLinkCustomDisplay.__init__(self) self.experiment = experiment self.my_canvas = canvas(self.experiment) self.my_keyboard = keyboard(self.experiment, timeout=0) self.my_mouse = mouse(self.experiment) self.__target_beep__ = synth(self.experiment, length = 50) self.__target_beep__done__ = synth(self.experiment, freq = 880, length = 200) self.__target_beep__error__ = synth(self.experiment, freq = 220, length = 200) self.state = None self.imagebuffer = array.array('l') self.pal = None self.size = (0,0) self.tmp_file = os.path.join(tempfile.gettempdir(), '__eyelink__.jpg') self.set_tracker(tracker) self.last_mouse_state = -1 self.experiment.eyelink_esc_pressed = False
def confirm_abort_experiment(self): """ Asks for confirmation before aborting the experiment. Displays a # confirmation screen, collects the response, and acts accordingly. Exceptions: Raises a response_error upon confirmation. Returns: False if no confirmation was given. """ # Display the confirmation screen conf_canvas = canvas(self.experiment) conf_kb = keyboard(self.experiment, timeout=None) yc = conf_canvas.ycenter() ld = 40 conf_canvas.clear() conf_canvas.text(u'Really abort experiment?', y=yc-3*ld) conf_canvas.text(u'Press \'Y\' to abort', y=yc-0.5*ld) conf_canvas.text(u'Press any other key or wait 5s to go to setup', \ y = yc+0.5*ld) conf_canvas.show() # process the response: try: key, time = conf_kb.get_key(timeout=5000) except: return False # if confirmation, close experiment if key == u'y': raise exceptions.runtime_error(u'The experiment was aborted') else: return False
def on_mouse_click(self, pos): """<DOC> Is called whenever the user clicks on the widget. Activates the text input for typing text. Arguments: pos -- an (x, y) tuple </DOC>""" self.focus = True my_keyboard = keyboard(self.form.experiment) while True: self.form.render() resp, time = my_keyboard.get_key() try: o = ord(resp) except: o = None if resp == 'space': self.text += ' ' elif resp == 'backspace' or o == 8: self.text = self.text[:-1] elif resp == 'tab': self.focus = False return None elif resp == 'return': if self.return_accepts: return self.text else: self.focus = False return None elif len(resp) == 1: self.text += resp self.set_var(self.text)
def drift_correction(self, pos = None, fix_triggered = False): """Dummy drift correction""" if fix_triggered: return self.fix_triggered_drift_correction(pos) self.simulator.set_visible(visible=True) my_keyboard = keyboard(self.experiment, keylist=["space"], timeout=0) errorbeep = synth(self.experiment, freq=220, length=200) if pos == None: pos = self.resolution[0] / 2, self.resolution[1] / 2 errdist = 60 # pixels (on a 1024x768px and 39.9x29.9cm monitor at 67 cm, this is about 2 degrees of visual angle) pressed = None while not pressed: pressed, presstime = my_keyboard.get_key() if pressed: gazepos = self.sample() if ((gazepos[0]-pos[0])**2 + (gazepos[1]-pos[1])**2)**0.5 < errdist: self.simulator.set_visible(visible=False) return True errorbeep.play() self.simulator.set_visible(visible=False) return False
def list_keys(self): """Show a dialog with available key names""" my_keyboard = keyboard(self.experiment) s = _('The following key names are valid:<br />') \ + '<br />'.join(my_keyboard.valid_keys()) self.experiment.notify(s)
def on_mouse_click(self, pos): """ desc: Is called whenever the user clicks on the widget. Activates the text input for typing text. arguments: pos: desc: An (x, y) coordinates tuple. type: tuple """ self.focus = True self.caret_pos = len(self.text) my_keyboard = keyboard(self.form.experiment) my_keyboard.show_virtual_keyboard(True) while True: self.form.render() resp, time = my_keyboard.get_key() try: o = ord(resp) except: o = None if resp == u'space': self.text = self.text[:self.caret_pos] + u' ' +\ self.text[self.caret_pos:] self.caret_pos +=1 elif resp == u'backspace' or o == 8: self.text = self.text[:self.caret_pos-1] +\ self.text[self.caret_pos:] self.caret_pos = max(0,self.caret_pos-1) elif resp == u'delete': self.text = self.text[:self.caret_pos] +\ self.text[self.caret_pos+1:] elif resp == u'tab': self.focus = False my_keyboard.show_virtual_keyboard(False) return None elif resp == u'return' or resp == u'enter': if self.return_accepts: my_keyboard.show_virtual_keyboard(False) return self.text else: self.focus = False my_keyboard.show_virtual_keyboard(False) return None elif resp == u'left': self.caret_pos = max(0,self.caret_pos-1) elif resp == u'right': self.caret_pos = min(len(self.text),self.caret_pos+1) elif len(resp) == 1: self.text = self.text[:self.caret_pos] + resp +\ self.text[self.caret_pos:] self.caret_pos +=1 self.set_var(self.text)
def get_button_state(self): """See libboks.""" from openexp.keyboard import keyboard _buttons = [str(b) for b in self.buttons] kb = keyboard(self.experiment, keylist=_buttons, timeout=0) key, timestamp = kb.get_key() if key == None: return [] return [int(key)]
def list_keys(self): """Show a dialog with available key names""" my_keyboard = keyboard(self.experiment) keylist = filter(lambda key: key.strip(), my_keyboard.valid_keys()) md = u'# ' + _(u'Key names') + u'\n\n' \ + _(u'The following key names are valid:') + u'\n\n- ' \ + u'\n- '.join([u'`%s`' % key for key in keylist]) self.tabwidget.open_markdown(md, icon=u'os-keyboard_response', title=_(u'Key names'))
def prepare(self): """Preparation phase""" # Call the parent constructor. item.prepare(self) # create keyboard object self.kb = keyboard(self.experiment,timeout=1) self.init_var()
def get_button_press(self): """See libboks.""" from openexp.keyboard import keyboard _buttons = [str(b) for b in self.buttons] kb = keyboard(self.experiment, keylist=_buttons, timeout=self.timeout) key, timestamp = kb.get_key() # Make sure that we return `int`s instead of `str`s if key != None: key = int(key) return key, timestamp
def prepare(self): """ Prepare the item. In this case this means drawing a fixation dot to an offline canvas. """ # create offline canvas self.canvas = canvas(self.experiment, auto_prepare=False) self.canvas.set_bgcolor(self.get("bgc")) self.canvas.clear() # draw the stimulus self.sx = self.get("width")/2 self.sy = self.get("height")/2 self.r = self.get("stims")/2 self.canvas.circle(self.sx,self.sy,self.r,fill=True,color=self.get("fgc")) # create keyboard object if self.allow_keyboard == 'yes': kl = self.get("kl").split(';') self.kb = keyboard(self.experiment, keylist=kl, timeout=None) # calculate vibration time (ms) self.experiment.set("T", (1 / float(self.get("freq"))) * 1000) # determine functions for stepsize if self.get("direct") == 'horizontal': if self.get("mtype") == 'sinusoid': self.fx = self.sinusoid elif self.get("mtype") == 'linear': self.fx = self.linear else: self.fx = self.no_change print("Error in smooth_pursuit.prepare: unknown movement type!") self.fy = self.no_change elif self.get("direct") == 'vertical': if self.mtype == 'sinusoid': self.fy = self.sinusoid elif self.mtype == 'linear': self.fy = self.linear else: self.fy = self.no_change print("Error in smooth_pursuit.prepare: unknown movement type!") self.fx = self.no_change # Pass the word on to the parent item.item.prepare(self) # Report success return True
def __init__(self, experiment, src): # Create required elements self.panner = gst.element_factory_make("audiopanorama","panner") self.pitcher = gst.element_factory_make("pitch","pitch_controller") convert = gst.element_factory_make("audioconvert", "convert") audiosink = gst.element_factory_make("autoaudiosink","playback") # Put in bin and link elements together output_bin = gst.Bin("postprocessing") output_bin.add_many(self.pitcher, self.panner, convert, audiosink) gst.element_link_many(self.pitcher, self.panner, convert, audiosink) # Create pad (entry point for playbin2 in output_bin) pad = self.pitcher.get_static_pad("sink") ghost_pad = gst.GhostPad("sink", pad) ghost_pad.set_active(True) output_bin.add_pad(ghost_pad) # Create player and route output to bin self.player = gst.element_factory_make("playbin2", "player") self.player.set_property("audio-sink", output_bin) # Create bus reference to keep track of what's happening in the player self.bus = self.player.get_bus() self.bus.enable_sync_message_emission() if src != None: if not os.path.exists(src): raise osexception( u"openexp._sampler.gstreamer.__init__() the file '%s' does not exist" \ % src) else: # Determine URI to file source src = os.path.abspath(src) src = urlparse.urljoin('file:', urllib.pathname2url(src)) self.player.set_property("uri", src) self.player.set_state(gst.STATE_PAUSED) self.experiment = experiment self.keyboard = keyboard(experiment) # Handler of Gstreamer messages self.gst_listener = threading.Thread(target=self._monitor_events, args=()) self._playing = False self._end_of_stream_reached = False self._stop_after = 0 self._fade_in = 0 self._volume = 1.0
def list_keys(self): """Show a dialog with available key names""" my_keyboard = keyboard(self.experiment) s = "The following keys have been detected. Note that different backends may use slightly different names.<br /><br />" s += "Keyboard backend: %s<br/><br />" % self.get("keyboard_backend") for name in sorted(my_keyboard.valid_keys()): s += "Key: <b>%s</b><br />" % cgi.escape(str(name)) syn = my_keyboard.synonyms(name) if syn != [name]: s += "(or %s)<br />" % (", ".join([cgi.escape(str(x)) for x in syn])) self.experiment.notify(s)
def fix_triggered_drift_correction(self, pos = None, min_samples = 30, max_dev = 60, reset_threshold = 10): """Dummy drift correction (fixation triggered)""" self.simulator.set_visible(visible=True) if pos == None: pos = self.resolution[0] / 2, self.resolution[1] / 2 self.prepare_drift_correction(pos) my_keyboard = keyboard(self.experiment, keylist=["escape", "q"], timeout=0) # loop until we have sufficient samples lx = [] ly = [] while len(lx) < min_samples: # pressing escape enters the calibration screen if my_keyboard.get_key()[0] != None: self.simulator.set_visible(visible=False) self.recording = False print("libeyelink.fix_triggered_drift_correction(): 'q' pressed") return False # collect a sample x, y = self.sample() if len(lx) == 0 or x != lx[-1] or y != ly[-1]: # if present sample deviates too much from previous sample, reset counting if len(lx) > 0 and (abs(x - lx[-1]) > reset_threshold or abs(y - ly[-1]) > reset_threshold): lx = [] ly = [] # collect samples else: lx.append(x) ly.append(y) if len(lx) == min_samples: avg_x = sum(lx) / len(lx) avg_y = sum(ly) / len(ly) d = ((avg_x - pos[0]) ** 2 + (avg_y - pos[1]) ** 2)**0.5 if d < max_dev: self.simulator.set_visible(visible=False) return True else: lx = [] ly = []
def wait_no_button_pressed(self, feedback_stimulus_text=None, polling_intervall=500): """level detection needs to be switch on display feedback_stimulus (optional) if one button pressed """ if rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \ rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0: if feedback_stimulus_text is not None: cnv = canvas(self._exp) cnv.text(feedback_stimulus_text) cnv.show() kbd = keyboard(self._exp) while rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \ rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0: kbd.get_key(timeout=polling_intervall)
def make_connection(self): """hand shake and filename, returns forceDAQ version """ kbd = keyboard(self._exp) cnv = canvas(self._exp) cnv.text("Prepare force recording <br> press key if ready") cnv.show() kbd.get_key() canvas(self._exp).show() while not self.udp.connect_peer(FORCE_SERVER_IP): cnv = canvas(self._exp) cnv.text("ERROR while connecting to server <br> try again or Q to quit") cnv.show() key = kbd.get_key() if key[0] == u'q': msg = "Experiment quitted by user!" self.udp.send(rc.Command.QUIT) print(msg) self._exp.end() exit() canvas(self._exp).show() self.clock.wait(300) cnv = canvas(self._exp) cnv.text("Connected") cnv.show() self.clock.wait(500) self.udp.send(rc.Command.FILENAME + "{0}_{1}.csv".format(self.experiment_name, self.subject_number)) rtn = self.udp.receive(5) # paused if rtn is None: msg = "Force server not responding" cnv = canvas(self._exp) cnv.text(msg) cnv.show() kbd.get_key() self.udp.send(rc.Command.QUIT) print(msg) self._exp.end() exit() version = rc.get_data(rc.Command.GET_VERSION) cnv = canvas(self._exp) cnv.text("Connected <br> Version " + version) cnv.show() self.clock.wait(1000) return version
def prepare(self): """Prepare the boks""" item.item.prepare(self) self._keyboard = keyboard(self.experiment) # Prepare the device string if self.get(u'_dummy') == u'yes': dev = u'dummy' else: dev = self.get(u'dev') if dev == u'autodetect': dev = None # Dynamically load a boks instance if not hasattr(self.experiment, u'boks'): self.experiment.boks = libboks.libboks(dev, experiment= \ self.experiment) self.experiment.cleanup_functions.append(self.close) model, firmware_version = self.experiment.boks.info() self.experiment.set(u'boks_model', model) self.experiment.set(u'boks_firmware_version', firmware_version) # Prepare the allowed responses if self.has(u"allowed_responses"): self._allowed_responses = [] for r in self.unistr(self.get(u"allowed_responses")).split(u";"): if r.strip() != u"": try: r = int(r) except: raise exceptions.runtime_error( \ u"'%s' is not a valid response in boks '%s'. Expecting a number in the range 1 .. 4." \ % (r, self.name)) if r not in range(1,9): raise exceptions.runtime_error( \ u"'%s' is not a valid response in boks '%s'. Expecting a number in the range 1 .. 8." \ % (r, self.name)) self._allowed_responses.append(r) if len(self._allowed_responses) == 0: self._allowed_responses = None else: self._allowed_responses = None debug.msg(u"allowed responses set to %s" % self._allowed_responses) # Prepare the timeout self.prepare_timeout()
def set_canvas(self, txt, time, fontsize, keypress = False): #"""Create and show a sketchpad element in Opensesame.""" self.init_canvas.clear() self.init_canvas.set_font(style='serif',size=fontsize) self.init_canvas.text(txt) self.init_canvas.show() self.experiment.sleep(time) if keypress : # Add a keyboard object to be able to know when you press the spacebar my_keyboard = keyboard(self.experiment, keylist=['space']) while True: key, end_time = my_keyboard.get_key(timeout= 500) if key == 'space': break
def prepare(self): """Preparation phase""" # Call the parent constructor. item.prepare(self) # create keyboard object self.kb = keyboard(self.experiment,timeout=1) if hasattr(self.experiment, "pptrigger_dummy"): self.pptrigger_dummy = self.experiment.pptrigger_dummy else: raise osexception( u'Parallel Port init is missing')
def prepare(self): """ Prepare the plug-in Returns: True """ # check for eyetracker if not hasattr(self.experiment, "eyetracker"): raise exceptions.runtime_error( \ u"Please connect to the eyetracker using the the eyetracker_calibrate plugin before using the AOI plugin") # timeout if type(self.get(u'timeout')) == int: self.notimeout = False else: self.notimeout = True # canvas self.cv = openexp.canvas.canvas(self.experiment) self.cv.copy(self.experiment.items[self.get(u'spname')].canvas) # keyboard self.kb = keyboard(self.experiment, keylist=None, timeout=1) # string to dict exec("self.aoidict = %s" % self.get("aoidictstr")) # create numpy arrays (for faster processing) blnkarray = numpy.array(numpy.zeros(len(self.aoidict)),dtype=numpy.int) self._lx = numpy.array(blnkarray, copy=True) # left x border self._rx = numpy.array(blnkarray, copy=True) # right x border self._ty = numpy.array(blnkarray, copy=True) # top y border self._by = numpy.array(blnkarray, copy=True) # bottom y border self._namelist = numpy.array(self.aoidict.keys()) self._aoicount = numpy.zeros(len(self._namelist)) self._notaoicount = 0 for aoinr in range(0,len(self._namelist)): x, y, w, h = self.aoidict[self._namelist[aoinr]] self._lx[aoinr] = x self._rx[aoinr] = x + w self._ty[aoinr] = y self._by[aoinr] = y + h return True
def prepare(self): """ Prepare the item. In this case this means drawing a fixation dot to an offline canvas. """ # create offline canvas self.canvas = canvas(self.experiment) self.canvas.set_bgcolor(self.get("bgc")) self.canvas.clear() # create keyboard object if self.allow_keyboard == 'yes': kl = self.get("kl").split(';') self.kb = keyboard(self.experiment, keylist=kl, timeout=None) # calculate stimulus radius self.r = self.get("stims")/2 # define positions if self.get("direct") == "horizontal": self.positions = [ (self.get("width")/2 - self.get("amp"), self.get("height")/2), (self.get("width")/2 + self.get("amp"), self.get("height")/2) ] elif self.get("direct") == "vertical": self.positions = [ (self.get("width")/2, self.get("height")/2 - self.get("amp")), (self.get("width")/2, self.get("height")/2 + self.get("amp")) ] else: self.positions = [ (self.get("width")/2, self.get("height")/2), (self.get("width")/2, self.get("height")/2) ] print("Error in saccade.prepare: unkown direction!") # calculate vibration time (ms) self.experiment.set("T", (1 / float(self.get("freq"))) * 1000) # Pass the word on to the parent item.item.prepare(self) # Report success return True
def prepare_response_func(self): """See base_response_item.""" self._keyboard = keyboard(self.experiment, keylist=self._allowed_responses, timeout=self._timeout) if self.var._dummy == u'yes': return self._keyboard.get_key # Dynamically load a joystick instance if not hasattr(self.experiment, u'joystick'): _joystick = plugins.load_mod(__file__, u'libjoystick') self.experiment.joystick = _joystick.libjoystick( self.experiment, device=self._device) self.python_workspace[u'joystick'] = self.experiment.joystick if self._allowed_responses is not None: self._allowed_responses = [int(r) for r in self._allowed_responses] return self._get_button_press
def __init__(self, keylist=KEYLIST, timeout=KEYTIMEOUT): # See _keyboard.basekeyboard.BaseKeyboard # try to copy docstring (but ignore it if it fails, as we do # not need it for actual functioning of the code) try: copy_docstr(BaseKeyboard, OSKeyboard) except: # we're not even going to show a warning, since the copied # docstring is useful for code editors; these load the docs # in a non-verbose manner, so warning messages would be lost pass self.experiment = osexperiment self.keyboard = keyboard(self.experiment, keylist=keylist, timeout= \ timeout)
def warn(self): """Show screen to warn user that no markers will be send to the VU-AMS device""" my_canvas = canvas(self.experiment) my_canvas.set_font(size=32) my_canvas.set_bgcolor(u'yellow') my_canvas.clear() my_canvas.set_fgcolor(u'red') my_canvas.text(u'Warning: <b>no markers</b> will be sent to the VU-AMS! \n\n <i>Hit "c" to Continue or "Esc" to quit</i>') my_canvas.show() my_keyboard = keyboard(self.experiment) my_keyboard.get_key(keylist=[u'c', u'C']) my_canvas.set_font(size=21) my_canvas.set_bgcolor(u'black') my_canvas.clear() my_canvas.set_fgcolor(u'purple') my_canvas.text(u'Preparing experiment...') my_canvas.show()
def on_mouse_click(self, pos): """ desc: Is called whenever the user clicks on the widget. Activates the text input for typing text. arguments: pos: desc: An (x, y) coordinates tuple. type: tuple """ self.focus = True my_keyboard = keyboard(self.form.experiment) my_keyboard.show_virtual_keyboard(True) while True: self.form.render() resp, time = my_keyboard.get_key() try: o = ord(resp) except: o = None if resp == u"space": self.text += " " elif resp == u"backspace" or o == 8: self.text = self.text[:-1] elif resp == u"tab": self.focus = False my_keyboard.show_virtual_keyboard(False) return None elif resp == u"return": if self.return_accepts: my_keyboard.show_virtual_keyboard(False) return self.text else: self.focus = False my_keyboard.show_virtual_keyboard(False) return None elif len(resp) == 1: self.text += resp self.set_var(self.text)
def keyboard(**resp_args): """ desc: | A convenience function that creates a new `keyboard` object. For a description of possible keywords, see: - [/python/keyboard/](/python/keyboard/) returns: desc: A `keyboard` object. type: keyboard example: | my_keyboard = keyboard(keylist=[u'a', u'b'], timeout=5000) key, time = my_keyboard.get_key() """ from openexp.keyboard import keyboard return keyboard(experiment, **resp_args)
def __init__(self, experiment, src, **playback_args): if src is not None: if isinstance(src, basestring): if not os.path.exists(src): raise osexception( \ u"openexp._sampler.legacy.__init__() the file '%s' does not exist" \ % src) if os.path.splitext(src)[1].lower() not in (".ogg", ".wav"): raise osexception( \ u"openexp._sampler.legacy.__init__() the file '%s' is not an .ogg or .wav file" \ % src) # The mixer chokes on unicode pathnames that contain special # characters. To avoid this we convert to str with the # filesystem encoding. (Python 2 only). if not py3 and isinstance(src, str): import sys src = src.encode(misc.filesystem_encoding()) self.sound = mixer.Sound(src) sampler.sampler.__init__(self, experiment, src, **playback_args) self.keyboard = keyboard(experiment)
def hold_check(self, holding_time=3000, left_pos=-200, right_pos=200, radius=50, col_fine='gray', col_too_low='green', col_too_strong='red'): kbd = keyboard(self._exp) blank = canvas(self._exp) blank.show() self.udp.send("hold:test") self.clock.reset_stopwatch() prev_lv = None while True: self.udp.clear_receive_buffer() lv = [rc.get_data(rc.Command.GET_THRESHOLD_LEVEL), rc.get_data(rc.Command.GET_THRESHOLD_LEVEL2)] if prev_lv!=lv: # level has changes self.clock.reset_stopwatch() prev_lv = lv cnv = canvas(self._exp) for i, pos in enumerate([left_pos, right_pos]): if lv[i] == WEAK: cnv.circle(x=pos, y=0, r=radius, fill=True, color=col_too_low) elif lv[i] == STRONG: cnv.circle(x=pos, y=0, r=radius, fill=True, color=col_too_strong) elif lv[i] == FINE: cnv.circle(x=pos, y=0, r=radius, fill=True, color=col_fine) cnv.show() key, _ = kbd.get_key(timeout=0) if (lv == [FINE, FINE] and self.clock.stopwatch_time > holding_time) or\ (key is not None): break blank.show()
def __init__(self, experiment, src): if src != None: if isinstance(src, basestring): if not os.path.exists(src): raise osexception( \ u"openexp._sampler.legacy.__init__() the file '%s' does not exist" \ % src) if os.path.splitext(src)[1].lower() not in (".ogg", ".wav"): raise osexception( \ u"openexp._sampler.legacy.__init__() the file '%s' is not an .ogg or .wav file" \ % src) # The mixer chokes on unicode pathnames that contain special # characters. To avoid this we convert to str with the filesystem # encoding. if isinstance(src, unicode): import sys src = src.encode(misc.filesystem_encoding()) self.sound = mixer.Sound(src) self.experiment = experiment self.keyboard = keyboard(experiment) self._stop_after = 0 self._fade_in = 0 self._volume = 1.0