def _create_surface(self):
"""Create the surface of the stimulus."""
surface = pygame.image.load(unicode2str(self._filename,
fse=True)).convert_alpha()
if self._logging:
expyriment._active_exp._event_file_log(
"Picture,loaded,{0}".format(unicode2str(self._filename)), 1)
return surface
def _create_surface(self):
"""Create the surface of the stimulus."""
surface = pygame.image.load(unicode2str(self._filename,
fse=True)).convert_alpha()
if self._logging:
expyriment._active_exp._event_file_log(
"Picture,loaded,{0}".format(unicode2str(self._filename)), 1)
return surface
def __init__(self, filename, position=None):
"""Create a video stimulus.
Parameters
----------
filename : str
filename (incl. path) of the video
position : (int, int), optional
position of the stimulus
Notes
-----
Only MPEG-1 movies with MP3 audio are supported. You can use ffmpeg
(www.ffmpeg.org) to convert from other formats:
ffmpeg -i <inputfile> -vcodec mpeg1video -acodec libmp3lame -intra -qscale 2 <outputfile.mpg>
The -qscale option is the quality setting. It can take values from 1 to 31.
1 is the best quality, but big file size. 31 is the worst quality, but
small file size. Play around with this setting to get a good balance
between quality and file size.
"""
_visual.Stimulus.__init__(self, filename)
self._filename = filename
self._is_preloaded = False
self._frame = 0
if position:
self._position = position
else:
self._position = defaults.video_position
if not (os.path.isfile(self._filename)):
raise IOError("The video file {0} does not exists".format(
unicode2str(self._filename)))
def _create_surface(self):
"""Create the surface of the stimulus."""
rect = pygame.Rect((0, 0), self.size)
if os.path.isfile(self._text_font):
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
self._text_size)
else:
_font = pygame.font.Font(self._text_font, self._text_size)
_font.set_bold(self.text_bold)
_font.set_italic(self.text_italic)
_font.set_underline(self.text_underline)
if type(self.text) is not unicode:
# Pygame wants latin-1 encoding here for character strings
_text = str2unicode(self.text).encode('latin-1')
else:
_text = self.text
surface = self.render_textrect(self.format_block(_text),
_font, rect, self.text_colour,
self.background_colour,
self.text_justification)
return surface
def play(self):
"""Play the video stimulus from the current position.
Notes
-----
When the audio from the video should be played as well, the audiosystem
has to be stopped (by calling expyriment.control.stop_audiosystem() )
BEFORE the video stimulus is preloaded! After the stimulus has been played
the audiosystem can be started again (by calling
expyriment.control.start_audiosystem() ).
When showing videos in large dimensions, and your computer is not fast
enough, frames might be dropped! When using Video.wait_frame() or
Video.wait_end(), dropped video frames will be reported and logged.
"""
if mixer.get_init() is not None:
message = "Mixer is still initialized, cannot play audio! Call \
expyriment.control.stop_audiosystem() before preloading the video."
print "Warning: ", message
if self._logging:
expyriment._active_exp._event_file_log(
"Video,warning," + message)
if not self._is_preloaded:
self.preload()
if self._logging:
expyriment._active_exp._event_file_log(
"Video,playing,{0}".format(unicode2str(self._filename)))
self._file.play()
def _create_surface(self):
"""Create the surface of the stimulus."""
if os.path.isfile(self._text_font):
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
self._text_size)
else:
_font = pygame.font.Font(self._text_font, self._text_size)
_font.set_bold(self.text_bold)
_font.set_italic(self.text_italic)
_font.set_underline(self.text_underline)
if type(self.text) is not unicode:
# Pygame wants latin-1 encoding here for character strings
_text = str2unicode(self.text).encode('latin-1')
else:
_text = self.text
if self.background_colour:
surface = _font.render(_text, True, self.text_colour,
self.background_colour)
else:
surface = _font.render(_text, True, self.text_colour)
surface = surface.convert_alpha()
if self._max_width > 0 and surface.get_size()[0] > self._max_width:
# trim too long text lines
self._text = self._text[:-2] + "~"
surface = self._create_surface() # recursion
return surface
def __init__(self, filename, position=None):
"""Create a video stimulus.
Parameters
----------
filename : str
filename (incl. path) of the video
position : (int, int), optional
position of the stimulus
Notes
-----
Only MPEG-1 movies with MP3 audio are supported. You can use ffmpeg
(www.ffmpeg.org) to convert from other formats:
ffmpeg -i <inputfile> -vcodec mpeg1video -acodec libmp3lame -intra -qscale 2 <outputfile.mpg>
The -qscale option is the quality setting. It can take values from 1 to 31.
1 is the best quality, but big file size. 31 is the worst quality, but
small file size. Play around with this setting to get a good balance
between quality and file size.
"""
_visual.Stimulus.__init__(self, filename)
self._filename = filename
self._is_preloaded = False
self._frame = 0
if position:
self._position = position
else:
self._position = defaults.video_position
if not(os.path.isfile(self._filename)):
raise IOError("The video file {0} does not exists".format(
unicode2str(self._filename)))
def preload(self):
"""Preload stimulus to memory.
Notes
-----
When the audio from the video should be played as well, the audiosystem
has to be stopped (by calling expyriment.control.stop_audiosystem() )
BEFORE the video stimulus is preloaded! After the stimulus has been played
the audiosystem can be started again (by calling
expyriment.control.start_audiosystem() ).
"""
if not self._is_preloaded:
self._file = pygame.movie.Movie(
unicode2str(self._filename, fse=True))
screen_size = expyriment._active_exp.screen.surface.get_size()
self._pos = [
screen_size[0] / 2 - self._file.get_size()[0] / 2 +
self._position[0], screen_size[1] / 2 -
self._file.get_size()[1] / 2 - self._position[1]
]
size = self._file.get_size()
self._surface = pygame.surface.Surface(size)
self._file.set_display(self._surface)
self._is_preloaded = True
def _create_surface(self):
"""Create the surface of the stimulus."""
if os.path.isfile(self._text_font):
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
self._text_size)
else:
_font = pygame.font.Font(self._text_font, self._text_size)
_font.set_bold(self.text_bold)
_font.set_italic(self.text_italic)
_font.set_underline(self.text_underline)
if type(self.text) is not unicode:
# Pygame wants latin-1 encoding here for character strings
_text = str2unicode(self.text).encode('latin-1')
else:
_text = self.text
if self.background_colour:
surface = _font.render(_text, True, self.text_colour,
self.background_colour)
else:
surface = _font.render(_text, True, self.text_colour)
surface.convert_alpha()
if self._max_width > 0 and surface.get_size()[0] > self._max_width:
# trim too long text lines
self._text = self._text[:-2] + "~"
surface = self._create_surface() # recursion
return surface
def preload(self):
"""Preload stimulus to memory.
Notes
-----
When the audio from the video should be played as well, the audiosystem
has to be stopped (by calling expyriment.control.stop_audiosystem() )
BEFORE the video stimulus is preloaded! After the stimulus has been played
the audiosystem can be started again (by calling
expyriment.control.start_audiosystem() ).
"""
if not self._is_preloaded:
self._file = pygame.movie.Movie(unicode2str(self._filename,
fse=True))
screen_size = expyriment._active_exp.screen.surface.get_size()
self._pos = [screen_size[0] / 2 - self._file.get_size()[0] / 2 +
self._position[0],
screen_size[1] / 2 - self._file.get_size()[1] / 2 -
self._position[1]]
size = self._file.get_size()
self._surface = pygame.surface.Surface(size)
self._file.set_display(self._surface)
self._is_preloaded = True
def play(self):
"""Play the video stimulus from the current position.
Notes
-----
When the audio from the video should be played as well, the audiosystem
has to be stopped (by calling expyriment.control.stop_audiosystem() )
BEFORE the video stimulus is preloaded! After the stimulus has been played
the audiosystem can be started again (by calling
expyriment.control.start_audiosystem() ).
When showing videos in large dimensions, and your computer is not fast
enough, frames might be dropped! When using Video.wait_frame() or
Video.wait_end(), dropped video frames will be reported and logged.
"""
if mixer.get_init() is not None:
message = "Mixer is still initialized, cannot play audio! Call \
expyriment.control.stop_audiosystem() before preloading the video."
print "Warning: ", message
if self._logging:
expyriment._active_exp._event_file_log("Video,warning," +
message)
if not self._is_preloaded:
self.preload()
if self._logging:
expyriment._active_exp._event_file_log("Video,playing,{0}".format(
unicode2str(self._filename)))
self._file.play()
def _create_surface(self):
"""Create the surface of the stimulus."""
rect = pygame.Rect((0, 0), self.size)
if os.path.isfile(self._text_font):
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
self._text_size)
else:
_font = pygame.font.Font(self._text_font, self._text_size)
_font.set_bold(self.text_bold)
_font.set_italic(self.text_italic)
_font.set_underline(self.text_underline)
if type(self.text) is not unicode:
# Pygame wants latin-1 encoding here for character strings
_text = str2unicode(self.text).encode('latin-1')
else:
_text = self.text
surface = self.render_textrect(self.format_block(_text),
_font, rect, self.text_colour,
self.background_colour,
self.text_justification)
return surface
def _create_surface(self):
"""Create the surface of the stimulus."""
if os.path.isfile(self._text_font):
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
self._text_size)
else:
_font = pygame.font.Font(self._text_font, self._text_size)
_font.set_bold(self.text_bold)
_font.set_italic(self.text_italic)
_font.set_underline(self.text_underline)
if type(self.text) is not unicode:
# Pygame wants latin-1 encoding here for character strings
_text = str2unicode(self.text).encode('latin-1')
else:
_text = self.text
if self.background_colour:
text = _font.render(_text, True, self.text_colour,
self.background_colour)
else:
text = _font.render(_text, True, self.text_colour)
text.convert_alpha()
surface = text
return surface
def add_experiment_info(self, text):
"""Adds a text the subject info header.
Notes
-----
The next data.save() might take longer!
"""
if isinstance(text, types.UnicodeType):
text = "{0}".format(unicode2str(text))
elif type(text) is not str:
text = "{0}".format(text)
for line in text.splitlines():
self._experiment_info.append("{0}e {1}{2}".format(
unicode2str(self.comment_char), line,
unicode2str(defaults.outputfile_eol)))
def save(self):
"""Save the new data to data-file.
Returns
-------
time : int
the time it took to execute this method
"""
start = get_time()
if len(self._subject_info) > 0 or len(self._experiment_info) > 0 \
or self._variable_names_changed:
# Re-write header and varnames
tmpfile_name = "{0}{1}{2}".format(self.directory, os.path.sep, uuid.uuid4())
os.rename(self._fullpath, tmpfile_name)
fl = open(self._fullpath, 'w+')
tmpfl = open(tmpfile_name, 'r')
section = None
while True:
line = tmpfl.readline()
if not line:
break
if line.startswith(self.comment_char + "e"):
section = "e"
elif line.startswith(self.comment_char + "s"):
section = "s"
else:
if section == "e": # Previous line was last #e
if len(self._experiment_info) > 0:
fl.write("".join(self._experiment_info))
self._experiment_info = []
section = None
elif section == "s": # Previous line was last #s
if len(self._subject_info) > 0:
fl.write("".join(self._subject_info))
self._subject_info = []
section = None
# Re-write variable names after #s-section
fl.write(unicode2str(
self.variable_names + defaults.outputfile_eol))
self._variable_names_changed = False
line = '' # Skip old varnames
fl.write(line)
tmpfl.close()
fl.close()
os.remove(tmpfile_name)
self._subject_info = []
self._experiment_info = []
if self._buffer != []:
OutputFile.save(self)
if self._logging:
expyriment._active_exp._event_file_log("Data,saved")
return int((get_time() - start) * 1000)
def get(self, default_input=""):
"""Get input from user.
Notes
-----
This displays and updates the input box automatically. Pressing ENTER
returns the user input. Pressing ESC quits, returning an empty string.
Parameters
----------
default_input : str, optional
default input in the textbox
See Also
--------
design.experiment.register_wait_callback_function
"""
if android_show_keyboard is not None:
android_show_keyboard()
self._user = []
for char in default_input:
self._user.append(char)
self._create()
self._update()
if self._ascii_filter is None:
ascii_filter = range(0, 256) + constants.K_ALL_KEYPAD_DIGITS
else:
ascii_filter = self._ascii_filter
while True:
inkey, string = self._get_key()
if inkey == pygame.K_BACKSPACE:
self._user = self._user[0:-1]
elif inkey == pygame.K_RETURN or inkey == pygame.K_KP_ENTER:
break
elif inkey != pygame.K_LCTRL or inkey != pygame.K_RCTRL:
if not self._user_text_surface_size[0] >= self._max_size[0]:
if android is not None:
if inkey in ascii_filter:
if inkey in constants.K_ALL_KEYPAD_DIGITS:
inkey = numpad_digit_code2ascii(inkey)
self._user.append(chr(inkey))
else:
if inkey in constants.K_ALL_KEYPAD_DIGITS:
self._user.append(
chr(numpad_digit_code2ascii(inkey)))
elif string and ord(string) in ascii_filter:
self._user.append(string)
self._update()
got = "".join(self._user)
if self._logging:
expyriment._active_exp._event_file_log(
"TextInput,entered,{0}".format(unicode2str(got)))
if android_hide_keyboard is not None:
android_hide_keyboard()
return got
def get(self, default_input=""):
"""Get input from user.
Notes
-----
This displays and updates the input box automatically. Pressing ENTER
returns the user input. Pressing ESC quits, returning an empty string.
Parameters
----------
default_input : str, optional
default input in the textbox
See Also
--------
design.experiment.register_wait_callback_function
"""
if android_show_keyboard is not None:
android_show_keyboard()
self._user = []
for char in default_input:
self._user.append(char)
self._create()
self._update()
if self._ascii_filter is None:
ascii_filter = range(0, 256) + constants.K_ALL_KEYPAD_DIGITS
else:
ascii_filter = self._ascii_filter
while True:
inkey, string = self._get_key()
if inkey == pygame.K_BACKSPACE:
self._user = self._user[0:-1]
elif inkey == pygame.K_RETURN or inkey == pygame.K_KP_ENTER:
break
elif inkey != pygame.K_LCTRL or inkey != pygame.K_RCTRL:
if not self._user_text_surface_size[0] >= self._max_size[0]:
if android is not None:
if inkey in ascii_filter:
if inkey in constants.K_ALL_KEYPAD_DIGITS:
inkey = numpad_digit_code2ascii(inkey)
self._user.append(chr(inkey))
else:
if inkey in constants.K_ALL_KEYPAD_DIGITS:
self._user.append(chr(numpad_digit_code2ascii(inkey)))
elif string and ord(string) in ascii_filter:
self._user.append(string)
self._update()
got = "".join(self._user)
if self._logging:
expyriment._active_exp._event_file_log("TextInput,entered,{0}".format(unicode2str(got)))
if android_hide_keyboard is not None:
android_hide_keyboard()
return got
def write_line(self, content):
"""Write a text line to files.
Parameters
----------
content : str
content to be written (anything, will be casted to str)
"""
self.write(content)
self.write(unicode2str(defaults.outputfile_eol))
def write_comment(self, comment):
"""Write a comment line to files.
(i.e., text is proceeded by comment char).
Parameters
----------
comment : str
comment to be written (anything, will be casted to str)
"""
self.write(unicode2str(self.comment_char))
self.write_line(comment)
def add_subject_info(self, text):
"""Adds a text the subject info header.
Subject information can be extracted afterwards using
misc.data_preprocessing.read_data_file. To defined between subject
variables use a syntax like this: "gender = female" or
"handedness : left"
Parameters
----------
text : str
subject infomation to be add to the file header
Notes
-----
The next data.save() might take longer!
"""
self._subject_info.append("{0}s {1}{2}".format(
unicode2str(self.comment_char), unicode2str(text),
unicode2str(defaults.outputfile_eol)))
def write(self, content):
"""Write to file.
Parameters
----------
content : str
content to be written (anything, will be casted to str)
"""
if type(content) is unicode:
self._buffer.append(unicode2str(content))
else:
self._buffer.append(str(content))
def log(self, event):
"""Log an event.
Parameters
----------
event : anything
the event to be logged (anything, will be casted to str)
"""
if isinstance(event, types.UnicodeType):
event = unicode2str(event)
line = repr(self._clock.time) + self.delimiter + str(event)
self.write_line(line)
def write_list(self, list_):
"""Write a list in a row. Data are separated by a delimiter.
Parameters
----------
list_ : list
list to be written
"""
for elem in list:
self.write(elem)
self.write(',')
self.write(unicode2str(defaults.outputfile_eol))
def _typecheck_and_cast2str(data):
"""Check if data are string or numeric and cast to string"""
if data is None:
data = "None"
if isinstance(data, types.UnicodeType):
return unicode2str(data)
elif type(data) in [types.StringType, types.IntType,
types.LongType, types.FloatType,
types.BooleanType]:
return str(data)
else:
message = "Data to be added must to be " + \
"booleans, strings, numerics (i.e. floats or integers) " + \
"or None.\n {0} is not allowed.".format(type(data))
raise TypeError(message)
def preload(self):
"""Preload stimulus to memory."""
if not self._is_preloaded:
self._file = pygame.movie.Movie(unicode2str(self._filename,
fse=True))
screen_size = expyriment._active_exp.screen.surface.get_size()
self._pos = [screen_size[0] / 2 - self._file.get_size()[0] / 2 +
self._position[0],
screen_size[1] / 2 - self._file.get_size()[1] / 2 -
self._position[1]]
size = self._file.get_size()
self._surface = pygame.surface.Surface(size)
self._file.set_display(self._surface)
self._is_preloaded = True
def _typecheck_and_cast2str(data):
"""Check if data are string or numeric and cast to string"""
if data is None:
data = "None"
if isinstance(data, types.UnicodeType):
return unicode2str(data)
elif isinstance(data, types.StringType):
return str(data)
elif type(data) in [types.IntType, types.LongType, types.FloatType,
types.BooleanType]:
return repr(data)
else:
message = "Data to be added must to be " + \
"booleans, strings, numerics (i.e. floats or integers) " + \
"or None.\n {0} is not allowed.".format(type(data))
raise TypeError(message)
def __init__(self, filename):
"""Create an audio stimulus.
Parameters
----------
filename : str
the filename
"""
Stimulus.__init__(self, filename)
self._filename = filename
self._file = None
self._is_preloaded = False
if not(os.path.isfile(self._filename)):
raise IOError("The audio file {0} does not exists".format(
unicode2str(self._filename)))
def play(self):
"""Play the video stimulus from the current position."""
if mixer.get_init() is not None:
message = "Mixer is still initialized, cannot play audio! Call \
expyriment.control.stop_audiosystem() before preloading the video."
print "Warning: ", message
if self._logging:
expyriment._active_exp._event_file_log(
"Video,warning," + message)
if not self._is_preloaded:
self.preload()
if self._logging:
expyriment._active_exp._event_file_log(
"Video,playing,{0}".format(unicode2str(self._filename)))
self._file.play()
def __init__(self, filename):
"""Create an audio stimulus.
Parameters
----------
filename : str
the filename
"""
Stimulus.__init__(self, filename)
self._filename = filename
self._file = None
self._is_preloaded = False
if not (os.path.isfile(self._filename)):
raise IOError("The audio file {0} does not exists".format(
unicode2str(self._filename)))
def __init__(self, filename, position=None):
"""Create a picture.
Parameters
----------
filename : str
filename (incl. path) of the picture file
position :(int,int), optional
position of the stimulus
"""
if position is None:
position = defaults.picture_position
Visual.__init__(self, position, log_comment=filename)
self._filename = filename
if not(os.path.isfile(self._filename)):
raise IOError("The picture file '{0}' does not exist".format(
unicode2str(filename)))
def __init__(self, filename, position=None):
"""Create a picture.
Parameters
----------
filename : str
filename (incl. path) of the picture file
position :(int,int), optional
position of the stimulus
"""
if position is None:
position = defaults.picture_position
Visual.__init__(self, position, log_comment=filename)
self._filename = filename
if not (os.path.isfile(self._filename)):
raise IOError("The picture file '{0}' does not exist".format(
unicode2str(filename)))
def __init__(self, filename, encoding=None):
"""Create an input file.
All lines in the specified text file will be read into a list of
strings.
Parameters
----------
filename : str, optional
name of the input file
encoding : str, optional
the encoding used to read the content of the file
"""
self._filename = filename
self._current_line = 1
self._lines = []
if not(os.path.isfile(self._filename)):
raise IOError("The input file '{0}' does not exist.".format(
unicode2str(self._filename)))
if encoding is None:
with open(filename, 'r') as fl:
first_line = fl.readline()
encoding = re.findall("coding[:=]\s*([-\w.]+)", first_line)
if encoding == []:
second_line = fl.readline()
encoding = re.findall("coding[:=]\s*([-\w.]+)",
second_line)
if encoding == []:
encoding = [None]
else:
encoding = [encoding]
with codecs.open(self._filename, 'rb', encoding[0],
errors='replace') as f:
for line in f:
self._lines.append(str2unicode(line.rstrip('\r\n')))
def __init__(self, filename, position=None):
"""Create a video stimulus.
Parameters
----------
filename : str
filename (incl. path) of the video
position : (int, int), optional
position of the stimulus
"""
_visual.Stimulus.__init__(self, filename)
self._filename = filename
self._is_preloaded = False
self._frame = 0
if position:
self._position = position
else:
self._position = defaults.video_position
if not(os.path.isfile(self._filename)):
raise IOError("The video file {0} does not exists".format(
unicode2str(self._filename)))
def save(self, filename):
"""Save the stimulus as image.
Parameters
----------
filename : str
name of the file to write (possible extensions are BMP, TGA, PNG,
or JPEG with TGA being the default)
Notes
-----
Depending on the size of the stimulus, this method may take some time
to compute!
"""
parts = filename.split(".")
if len(parts) > 1:
parts[-1] = parts[-1].lower()
else:
parts.append("tga")
filename = ".".join(parts)
pygame.image.save(self._get_surface(), unicode2str(filename))
def save(self, filename):
"""Save the stimulation protocol to a csv file.
Parameters
----------
filename : str
The name of the file to save the protocol to
"""
with open(filename, 'w') as f:
try:
locale_enc = locale.getdefaultlocale()[1]
except:
locale_enc = "UTF-8"
f.write("# -*- coding: {0} -*-\n".format(locale_enc))
f.write("#unit={0}\n".format(self._unit))
f.write("condition,begin,end,weight\n")
for condition in self._conditions:
for event in condition["events"]:
f.write("{0},{1},{2},{3}\n".format(
unicode2str(condition["name"]), event["begin"],
event["end"], event["weight"]))
def start(experiment=None, auto_create_subject_id=None, subject_id=None,
skip_ready_screen=False):
"""Start an experiment.
This starts an experiment defined by 'experiment' and asks for the subject
number. When the subject number is entered and confirmed by ENTER, a data
file is created.
Eventually, "Ready" will be shown on the screen and the method waits for
ENTER to be pressed.
After experiment start the following additional properties are available:
* experiment.subject -- the current subject id
* experiment.data -- the main data file
Parameters
----------
experiment : design.Experiment, optional (DEPRECATED)
don't use this parameter, it only exists to keep backward compatibility
auto_create_subject_id : bool, optional
if True new subject id will be created automatically
subject_id : integer, optional
start with a specific subject_id;
no subject id input mask will be presented; subject_id must be an
integer; setting this paramter overrules auto_create_subject_id
skip_ready_screen : bool, optional
if True ready screen will be skipped (default=False)
Returns
-------
exp : design.Experiment
The started experiment will be returned.
"""
if experiment is None:
experiment = expyriment._active_exp
if experiment != expyriment._active_exp:
raise Exception("Experiment is not the currently initialized " +
"experiment!")
if experiment.is_started:
raise Exception("Experiment is already started!")
if subject_id is not None:
if not isinstance(subject_id, int):
raise Exception("Subject id must be an integer. " +
"{0} is not allowed.".format(type(subject_id)))
auto_create_subject_id = True
elif auto_create_subject_id is None:
auto_create_subject_id = defaults.auto_create_subject_id
experiment._is_started = True
# temporarily switch off log_level
old_logging = experiment.log_level
experiment.set_log_level(0)
screen_colour = experiment.screen.colour
experiment._screen.colour = [0, 0, 0]
if subject_id is None:
default_number = DataFile.get_next_subject_number()
else:
default_number = subject_id
if not auto_create_subject_id:
if android is not None:
background_stimulus = stimuli.BlankScreen(colour=(0, 0, 0))
fields = [stimuli.Circle(radius=100, colour=(70, 70, 70),
position=(0, 70), anti_aliasing=10),
stimuli.Circle(radius=100, colour=(70, 70, 70),
position=(0, -70), anti_aliasing=10),
stimuli.Rectangle(size=(50, 50), colour=(70, 70, 70),
position=(120, 0))]
fields[0].scale((0.25, 0.25))
fields[1].scale((0.25, 0.25))
plusminus = [
stimuli.TextLine("Subject Number:", text_size=24,
text_colour=constants.C_EXPYRIMENT_PURPLE,
position=(-182, 0)),
stimuli.FixCross(size=(15, 15), position=(0, 70),
colour=(0, 0, 0), line_width=2),
stimuli.FixCross(size=(15, 2), position=(0, -70),
colour=(0, 0, 0), line_width=2),
stimuli.TextLine(text = "Go", text_size=18, position=(120, 0),
text_colour=(0, 0, 0))]
subject_id = default_number
while True:
text = stimuli.TextLine(
text="{0}".format(subject_id),
text_size=28,
text_colour=constants.C_EXPYRIMENT_ORANGE)
btn = TouchScreenButtonBox(
button_fields=fields,
stimuli=plusminus+[text],
background_stimulus=background_stimulus)
btn.show()
key, rt = btn.wait()
if key == fields[0]:
subject_id += 1
elif key == fields[1]:
subject_id -= 1
if subject_id <= 0:
subject_id = 0
elif key == fields[2]:
break
experiment._subject = int(subject_id)
else:
position = (0, 0)
while True:
ask_for_subject = TextInput(
message="Subject Number:",
position=position,
message_colour=misc.constants.C_EXPYRIMENT_PURPLE,
message_text_size=24,
user_text_colour=misc.constants.C_EXPYRIMENT_ORANGE,
user_text_size=20,
background_colour=(0, 0, 0),
frame_colour=(70, 70, 70),
ascii_filter=misc.constants.K_ALL_DIGITS)
subject_id = ask_for_subject.get(repr(default_number))
try:
experiment._subject = int(subject_id)
break
except:
pass
else:
experiment._subject = default_number
experiment.screen.clear()
experiment.screen.update()
experiment._data = DataFile(additional_suffix=experiment.filename_suffix)
experiment.data.add_variable_names(experiment.data_variable_names)
for txt in experiment.experiment_info:
experiment.data.add_experiment_info(txt)
for line in experiment.__str__().splitlines():
experiment.data.add_experiment_info(line)
for f in experiment.bws_factor_names:
_permuted_bws_factor_condition = \
experiment.get_permuted_bws_factor_condition(f)
if isinstance(_permuted_bws_factor_condition, unicode):
_permuted_bws_factor_condition = \
unicode2str(_permuted_bws_factor_condition)
experiment.data.add_subject_info("{0} = {1}".format(
unicode2str(f), _permuted_bws_factor_condition))
if experiment.events is not None:
experiment.events._time_stamp = experiment.data._time_stamp
experiment.events.rename(experiment.events.standard_file_name)
number = defaults.initialize_delay - int(experiment.clock.time / 1000)
if number > 0:
text = stimuli.TextLine("Initializing, please wait...",
text_size=24,
text_colour=(160, 70, 250),
position=(0, 0))
stimuli._stimulus.Stimulus._id_counter -= 1
text.present()
text.present() # for flipping with double buffer
text.present() # for flipping with tripple buffer
while number > 0:
counter = stimuli.TextLine(
"{num:02d}".format(num=number),
text_font='FreeMono',
text_size=18,
text_bold=True,
text_colour=misc.constants.C_EXPYRIMENT_ORANGE,
position=(0, -50),
background_colour=(0, 0, 0))
stimuli._stimulus.Stimulus._id_counter -= 1
counter.present(clear=False)
number -= 1
key = experiment.keyboard.wait(pygame.K_ESCAPE, duration=1000,
check_for_control_keys=False)
if key[0] is not None:
break
position = (0, 0)
if not skip_ready_screen:
stimuli.TextLine("Ready", position=position, text_size=24,
text_colour=misc.constants.C_EXPYRIMENT_ORANGE).present()
stimuli._stimulus.Stimulus._id_counter -= 1
if android is None:
experiment.keyboard.wait()
else:
experiment.mouse.wait_press()
experiment.set_log_level(old_logging)
experiment._screen.colour = screen_colour
experiment.log_design_to_event_file()
experiment._event_file_log("Experiment,started")
return experiment
def preload(self):
"""Preload stimulus to memory."""
if not self._is_preloaded:
self._file = mixer.Sound(unicode2str(self._filename, fse=True))
self._is_preloaded = True
def __init__(self, text, size, position=None, text_font=None,
text_size=None, text_bold=None, text_italic=None,
text_underline=None, text_justification=None,
text_colour=None, background_colour=None,
do_not_trim_words=None):
"""Create a text box.
Notes
-----
text_font can be both, a name or path to a font file!
When text_font is a name, Expyriment will try to find a font that
best matches the given name.
If no matching font can be found, or if the given font file cannot be
found, the Pygame system default will be used.
In any case the value of the attribute text_font will always
resemble the font that is actually in use!
Parameters
----------
text : str
text to wrap
size : (int, int)
size of the text box
position : (int, int), optional
position of the stimulus
text_font : str, optional
text font to use as a name or as a path to a font file
text_size : int, optional
size of the text
text_bold : bool, optional
font should be bold
text_italic : bool, optional
font should be italic
text_underline : bool, optional
font should get an underline
text_justification : int, optional
text justification, 0 (left), 1 (center), 2 (right)
text_colour : (int, int, int), optional
colour of the text
background_colour : (int, int, int), optional
background colour
do_not_trim_words: bool, optional
if True, words that exceed the width of the text box
will be not be trimmed and an exception is raise instead.
default: False
"""
pygame.font.init()
if position is None:
position = defaults.textbox_position
Visual.__init__(self, position)
self._text = text
self._size = size
if text_size is None:
text_size = defaults.textbox_text_size
if text_size is not None:
self._text_size = text_size
else:
self._text_size = expyriment._active_exp.text_size
if text_font is None:
text_font = defaults.textbox_text_font
if text_font is not None:
self._text_font = find_font(text_font)
else:
self._text_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
10)
_font = None
except:
raise IOError("Font '{0}' not found!".format(text_font))
if text_bold is not None:
self._text_bold = text_bold
else:
self._text_bold = defaults.textbox_text_bold
if text_italic is not None:
self._text_italic = text_italic
else:
self._text_italic = defaults.textbox_text_italic
if text_underline is not None:
self._text_underline = text_underline
else:
self._text_underline = defaults.textbox_text_underline
if text_justification is not None:
self._text_justification = text_justification
else:
self._text_justification = defaults.textbox_text_justification
if text_colour is not None:
self._text_colour = text_colour
else:
if defaults.textbox_text_colour is not None:
self._text_colour = defaults.textbox_text_colour
else:
self._text_colour = expyriment._active_exp.foreground_colour
if background_colour is not None:
self._background_colour = background_colour
else:
self._background_colour = \
defaults.textbox_background_colour
if do_not_trim_words is not None:
self._do_not_trim_words = do_not_trim_words
else:
self._do_not_trim_words = defaults.textbox_do_not_trim_words
def wait_char(self, char, duration=None, check_for_control_keys=True):
"""Wait for character(s) (optionally for a certain amount of time).
This function will wait for one or more characters and returns the
found character as well as the reaction time.
(This function clears the event queue!)
Parameters
----------
char : int or list
a specific character or list of characters to wait for
duration : int, optional
maximal time to wait in ms
check_for_control_keys : bool, optional
checks if control key has been pressed (default=True)
Returns
-------
found : char
pressed charater
rt : int
reaction time in ms
See Also
--------
design.experiment.register_wait_callback_function
"""
if expyriment.control.defaults._skip_wait_functions:
return None, None
start = get_time()
rt = None
found_char = None
self.clear()
try:
char = list(char)
except:
char = [char]
pygame.event.pump()
done = False
while not done:
rtn_callback = expyriment._active_exp._execute_wait_callback()
if isinstance(rtn_callback, expyriment.control.CallbackQuitEvent):
done = True
rt = int((get_time() - start) * 1000)
found_char = rtn_callback
for event in pygame.event.get([pygame.KEYUP, pygame.KEYDOWN]):
if check_for_control_keys and Keyboard.process_control_keys(event):
done = True
elif event.type == pygame.KEYDOWN:
if event.unicode in char:
rt = int((get_time() - start) * 1000)
found_char = event.unicode
done = True
if duration and not done:
done = int((get_time() - start) * 1000) >= duration
time.sleep(0.0005)
if self._logging:
expyriment._active_exp._event_file_log(
"Keyboard,received,{0},wait_char".format(
unicode2str(found_char)))
return found_char, rt
def preload(self):
"""Preload stimulus to memory."""
if not self._is_preloaded:
self._file = mixer.Sound(unicode2str(self._filename, fse=True))
self._is_preloaded = True
def start(experiment=None,
auto_create_subject_id=None,
subject_id=None,
skip_ready_screen=False):
"""Start an experiment.
This starts an experiment defined by 'experiment' and asks for the subject
number. When the subject number is entered and confirmed by ENTER, a data
file is created.
Eventually, "Ready" will be shown on the screen and the method waits for
ENTER to be pressed.
After experiment start the following additional properties are available:
* experiment.subject -- the current subject id
* experiment.data -- the main data file
Parameters
----------
experiment : design.Experiment, optional (DEPRECATED)
don't use this parameter, it only exists to keep backward compatibility
auto_create_subject_id : bool, optional
if True new subject id will be created automatically
subject_id : integer, optional
start with a specific subject_id;
no subject id input mask will be presented; subject_id must be an
integer; setting this paramter overrules auto_create_subject_id
skip_ready_screen : bool, optional
if True ready screen will be skipped (default=False)
Returns
-------
exp : design.Experiment
The started experiment will be returned.
"""
if experiment is None:
experiment = expyriment._active_exp
if experiment != expyriment._active_exp:
raise Exception("Experiment is not the currently initialized " +
"experiment!")
if experiment.is_started:
raise Exception("Experiment is already started!")
if subject_id is not None:
if not isinstance(subject_id, int):
raise Exception("Subject id must be an integer. " +
"{0} is not allowed.".format(type(subject_id)))
auto_create_subject_id = True
elif auto_create_subject_id is None:
auto_create_subject_id = defaults.auto_create_subject_id
experiment._is_started = True
# temporarily switch off log_level
old_logging = experiment.log_level
experiment.set_log_level(0)
screen_colour = experiment.screen.colour
experiment._screen.colour = [0, 0, 0]
if subject_id is None:
default_number = DataFile.get_next_subject_number()
else:
default_number = subject_id
if not auto_create_subject_id:
if android is not None:
background_stimulus = stimuli.BlankScreen(colour=(0, 0, 0))
fields = [
stimuli.Circle(radius=100,
colour=(70, 70, 70),
position=(0, 70),
anti_aliasing=10),
stimuli.Circle(radius=100,
colour=(70, 70, 70),
position=(0, -70),
anti_aliasing=10),
stimuli.Rectangle(size=(50, 50),
colour=(70, 70, 70),
position=(120, 0))
]
fields[0].scale((0.25, 0.25))
fields[1].scale((0.25, 0.25))
plusminus = [
stimuli.TextLine("Subject Number:",
text_size=24,
text_colour=constants.C_EXPYRIMENT_PURPLE,
position=(-182, 0)),
stimuli.FixCross(size=(15, 15),
position=(0, 70),
colour=(0, 0, 0),
line_width=2),
stimuli.FixCross(size=(15, 2),
position=(0, -70),
colour=(0, 0, 0),
line_width=2),
stimuli.TextLine(text="Go",
text_size=18,
position=(120, 0),
text_colour=(0, 0, 0))
]
subject_id = default_number
while True:
text = stimuli.TextLine(
text="{0}".format(subject_id),
text_size=28,
text_colour=constants.C_EXPYRIMENT_ORANGE)
btn = TouchScreenButtonBox(
button_fields=fields,
stimuli=plusminus + [text],
background_stimulus=background_stimulus)
btn.show()
key, rt = btn.wait()
if key == fields[0]:
subject_id += 1
elif key == fields[1]:
subject_id -= 1
if subject_id <= 0:
subject_id = 0
elif key == fields[2]:
break
experiment._subject = int(subject_id)
else:
position = (0, 0)
while True:
ask_for_subject = TextInput(
message="Subject Number:",
position=position,
message_colour=misc.constants.C_EXPYRIMENT_PURPLE,
message_text_size=24,
user_text_colour=misc.constants.C_EXPYRIMENT_ORANGE,
user_text_size=20,
background_colour=(0, 0, 0),
frame_colour=(70, 70, 70),
ascii_filter=misc.constants.K_ALL_DIGITS)
subject_id = ask_for_subject.get(repr(default_number))
try:
experiment._subject = int(subject_id)
break
except:
pass
else:
experiment._subject = default_number
experiment.screen.clear()
experiment.screen.update()
experiment._data = DataFile(additional_suffix=experiment.filename_suffix)
experiment.data.add_variable_names(experiment.data_variable_names)
for txt in experiment.experiment_info:
experiment.data.add_experiment_info(txt)
for line in experiment.__str__().splitlines():
experiment.data.add_experiment_info(line)
for f in experiment.bws_factor_names:
_permuted_bws_factor_condition = \
experiment.get_permuted_bws_factor_condition(f)
if isinstance(_permuted_bws_factor_condition, unicode):
_permuted_bws_factor_condition = \
unicode2str(_permuted_bws_factor_condition)
experiment.data.add_subject_info("{0} = {1}".format(
unicode2str(f), _permuted_bws_factor_condition))
if experiment.events is not None:
experiment.events._time_stamp = experiment.data._time_stamp
experiment.events.rename(experiment.events.standard_file_name)
number = defaults.initialize_delay - int(experiment.clock.time / 1000)
if number > 0:
text = stimuli.TextLine("Initializing, please wait...",
text_size=24,
text_colour=(160, 70, 250),
position=(0, 0))
stimuli._stimulus.Stimulus._id_counter -= 1
text.present()
text.present() # for flipping with double buffer
text.present() # for flipping with tripple buffer
while number > 0:
counter = stimuli.TextLine(
"{num:02d}".format(num=number),
text_font='FreeMono',
text_size=18,
text_bold=True,
text_colour=misc.constants.C_EXPYRIMENT_ORANGE,
position=(0, -50),
background_colour=(0, 0, 0))
stimuli._stimulus.Stimulus._id_counter -= 1
counter.present(clear=False)
number -= 1
key = experiment.keyboard.wait(pygame.K_ESCAPE,
duration=1000,
check_for_control_keys=False)
if key[0] is not None:
break
position = (0, 0)
if not skip_ready_screen:
stimuli.TextLine(
"Ready",
position=position,
text_size=24,
text_colour=misc.constants.C_EXPYRIMENT_ORANGE).present()
stimuli._stimulus.Stimulus._id_counter -= 1
if android is None:
experiment.keyboard.wait()
else:
experiment.mouse.wait_press()
experiment.set_log_level(old_logging)
experiment._screen.colour = screen_colour
experiment.log_design_to_event_file()
experiment._event_file_log("Experiment,started")
return experiment
def show_documentation(docu_type=None):
"""Show the Expyriment documentation.
Parameters
----------
docu_type : int
documentation type. Three options are available:
1) Open online documentation
2) Open online API reference
3) Open API reference and search tool
"""
from expyriment import get_version
def call_info():
print ""
print "Call show_documentation with the following arguments to get further information:"
print " show_documentation(1) -- Open local documentation in web browser"
print " show_documentation(2) -- Open online documentation in web browser"
print " show_documentation(3) -- Open API Reference Tool"
print ""
import subprocess
import os
import sys
import webbrowser
f = os.path.abspath(__file__)
path = os.path.abspath(os.path.join(os.path.split(f)[0], ".."))
if docu_type is None:
print "Welcome to Expyriment {0}".format(get_version())
print ""
author = __author__.replace(",", ",\n ")
print "Website: http://expyriment.org"
print "License: GNU GPL v3"
print "Authors: {0}".format(author)
call_info()
elif docu_type == 1:
docu = os.path.join(sys.prefix, 'share', 'expyriment', 'documentation',
'html', 'index.html')
if os.path.exists(docu):
from expyriment.misc import unicode2str
webbrowser.open(unicode2str('file://' + docu), new=1)
else:
print "No local documentation found"
elif docu_type == 2:
webbrowser.open("http://docs.expyriment.org/", new=1)
elif docu_type == 3:
python_executable = sys.executable.replace("pythonw.exe", "python.exe")
call = '"' + "{0}".format(python_executable) + \
'" -m expyriment._api_reference_tool'
_proc = subprocess.Popen(call,
shell=True,
stdin=None,
stdout=None,
cwd=path)
else:
print "Unknown documentation type"
call_info()
def wait_char(self, char, duration=None, check_for_control_keys=True):
"""Wait for character(s) (optionally for a certain amount of time).
This function will wait for one or more characters and returns the
found character as well as the reaction time.
(This function clears the event queue!)
Parameters
----------
char : int or list
a specific character or list of characters to wait for
duration : int, optional
maximal time to wait in ms
check_for_control_keys : bool, optional
checks if control key has been pressed (default=True)
Returns
-------
found : char
pressed charater
rt : int
reaction time in ms
See Also
--------
design.experiment.register_wait_callback_function
"""
if expyriment.control.defaults._skip_wait_functions:
return None, None
start = get_time()
rt = None
found_char = None
self.clear()
try:
char = list(char)
except:
char = [char]
pygame.event.pump()
done = False
while not done:
rtn_callback = expyriment._active_exp._execute_wait_callback()
if isinstance(rtn_callback, expyriment.control.CallbackQuitEvent):
done = True
rt = int((get_time() - start) * 1000)
found_char = rtn_callback
for event in pygame.event.get([pygame.KEYUP, pygame.KEYDOWN]):
if check_for_control_keys and Keyboard.process_control_keys(
event):
done = True
elif event.type == pygame.KEYDOWN:
if event.unicode in char:
rt = int((get_time() - start) * 1000)
found_char = event.unicode
done = True
if duration and not done:
done = int((get_time() - start) * 1000) >= duration
time.sleep(0.0005)
if self._logging:
expyriment._active_exp._event_file_log(
"Keyboard,received,{0},wait_char".format(
unicode2str(found_char)))
return found_char, rt
def __init__(self, text, position=None, text_font=None, text_size=None,
text_bold=None, text_italic=None, text_underline=None,
text_colour=None, background_colour=None, max_width=None):
"""Create a text line stimulus.
NOTE: text_font can be both, a name or path to a font file!
When text_font is a name, Expyriment will try to find a font that
best matches the given name.
If no matching font can be found, or if the given font file cannot be
found, the Pygame system default will be used.
In any case the value of the attribute text_font will always
resemble the font that is actually in use!
Parameters
----------
text : str
text to show (str)
position : (int, int), optional
position of the stimulus
text_font : str, optional
font to use as name or as path to a font file
text_size : int, optional
text size
text_bold : bool, optional
font should be bold
text_italic : bool, optional
font should be italic
text_underline : bool, optional
font should get an underline
text_colour : (int, int, int), optional
text colour
background_colour : (int, int, int), optional
background colour
max_width: int, optional
maximum surface width of the text line stimulus
if this parameter is defined, text lines that exceed this
surface width will be trimmed (indicated by a '~' as last letter)
"""
pygame.font.init()
if position is None:
position = defaults.textline_position
Visual.__init__(self, position, log_comment=text)
self._text = text
self._max_width = max_width
if text_size is None:
text_size = defaults.textline_text_size
if text_size is not None:
self._text_size = text_size
else:
self._text_size = expyriment._active_exp.text_size
if text_font is None:
text_font = defaults.textline_text_font
if text_font is not None:
self._text_font = find_font(text_font)
else:
self._text_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
10)
_font = None
except:
raise IOError("Font '{0}' not found!".format(text_font))
if text_bold is not None:
self._text_bold = text_bold
else:
self._text_bold = defaults.textline_text_bold
if text_italic is not None:
self._text_italic = text_italic
else:
self._text_italic = defaults.textline_text_italic
if text_underline is not None:
self._text_underline = text_underline
else:
self._text_underline = defaults.textline_text_underline
if text_colour is None:
text_colour = defaults.textline_text_colour
if text_colour is not None:
self._text_colour = text_colour
else:
self._text_colour = expyriment._active_exp.foreground_colour
if background_colour is not None:
self._background_colour = background_colour
else:
self._background_colour = \
defaults.textline_background_colour
def __init__(self,
text,
position=None,
text_font=None,
text_size=None,
text_bold=None,
text_italic=None,
text_underline=None,
text_colour=None,
background_colour=None,
max_width=None):
"""Create a text line stimulus.
NOTE: text_font can be both, a name or path to a font file!
When text_font is a name, Expyriment will try to find a font that
best matches the given name.
If no matching font can be found, or if the given font file cannot be
found, the Pygame system default will be used.
In any case the value of the attribute text_font will always
resemble the font that is actually in use!
Parameters
----------
text : str
text to show (str)
position : (int, int), optional
position of the stimulus
text_font : str, optional
font to use as name or as path to a font file
text_size : int, optional
text size
text_bold : bool, optional
font should be bold
text_italic : bool, optional
font should be italic
text_underline : bool, optional
font should get an underline
text_colour : (int, int, int), optional
text colour
background_colour : (int, int, int), optional
background colour
max_width: int, optional
maximum surface width of the text line stimulus
if this parameter is defined, text lines that exceed this
surface width will be trimmed (indicated by a '~' as last letter)
"""
pygame.font.init()
if position is None:
position = defaults.textline_position
Visual.__init__(self, position, log_comment=text)
self._text = text
self._max_width = max_width
if text_size is None:
text_size = defaults.textline_text_size
if text_size is not None:
self._text_size = text_size
else:
self._text_size = expyriment._active_exp.text_size
if text_font is None:
text_font = defaults.textline_text_font
if text_font is not None:
self._text_font = find_font(text_font)
else:
self._text_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
10)
_font = None
except:
raise IOError("Font '{0}' not found!".format(text_font))
if text_bold is not None:
self._text_bold = text_bold
else:
self._text_bold = defaults.textline_text_bold
if text_italic is not None:
self._text_italic = text_italic
else:
self._text_italic = defaults.textline_text_italic
if text_underline is not None:
self._text_underline = text_underline
else:
self._text_underline = defaults.textline_text_underline
if text_colour is None:
text_colour = defaults.textline_text_colour
if text_colour is not None:
self._text_colour = text_colour
else:
self._text_colour = expyriment._active_exp.foreground_colour
if background_colour is not None:
self._background_colour = background_colour
else:
self._background_colour = \
defaults.textline_background_colour
def __init__(self, text, size, position=None, text_font=None,
text_size=None, text_bold=None, text_italic=None,
text_underline=None, text_justification=None,
text_colour=None, background_colour=None):
"""Create a text box.
Notes
-----
text_font can be both, a name or path to a font file!
When text_font is a name, Expyriment will try to find a font that
best matches the given name.
If no matching font can be found, or if the given font file cannot be
found, the Pygame system default will be used.
In any case the value of the attribute text_font will always
resemble the font that is actually in use!
Parameters
----------
text : str
text to wrap
size : (int, int)
size of the text box
position : (int, int), optional
position of the stimulus
text_font : str, optional
text font to use as a name or as a path to a font file
text_size : int, optional
size of the text
text_bold : bool, optional
font should be bold
text_italic : bool, optional
font should be italic
text_underline : bool, optional
font should get an underline
text_justification : int, optional
text justification, 0 (left), 1 (center), 2 (right)
text_colour : (int, int, int), optional
colour of the text
background_colour : (int, int, int), optional
background colour
"""
pygame.font.init()
if position is None:
position = defaults.textbox_position
Visual.__init__(self, position)
self._text = text
self._size = size
if text_size is None:
text_size = defaults.textbox_text_size
if text_size is not None:
self._text_size = text_size
else:
self._text_size = expyriment._active_exp.text_size
if text_font is None:
text_font = defaults.textbox_text_font
if text_font is not None:
self._text_font = find_font(text_font)
else:
self._text_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
10)
_font = None
except:
raise IOError("Font '{0}' not found!".format(text_font))
if text_bold is not None:
self._text_bold = text_bold
else:
self._text_bold = defaults.textbox_text_bold
if text_italic is not None:
self._text_italic = text_italic
else:
self._text_italic = defaults.textbox_text_italic
if text_underline is not None:
self._text_underline = text_underline
else:
self._text_underline = defaults.textbox_text_underline
if text_justification is not None:
self._text_justification = text_justification
else:
self._text_justification = defaults.textbox_text_justification
if text_colour is not None:
self._text_colour = text_colour
else:
if defaults.textbox_text_colour is not None:
self._text_colour = defaults.textbox_text_colour
else:
self._text_colour = expyriment._active_exp.foreground_colour
if background_colour is not None:
self._background_colour = background_colour
else:
self._background_colour = \
defaults.textbox_background_colour
def __init__(self,
message="",
position=None,
ascii_filter=None,
length=None,
message_text_size=None,
message_colour=None,
message_font=None,
message_bold=None,
message_italic=None,
user_text_size=None,
user_text_bold=None,
user_text_font=None,
user_text_colour=None,
background_colour=None,
frame_colour=None,
gap=None,
screen=None,
background_stimulus=None):
"""Create a text input box.
Notes
-----
This stimulus is not optimized for timing accurate presentation!
Parameters
----------
message : str, optional
message to show
position : (int, int), optional
position of the TextInput canvas
length : int, optional
the length of the text input frame in number of charaters
ascii_filter : list, optional
list of ASCII codes to filter for
message_text_size : int, optional
text size of the message
message_colour : (int, int, int), optional
text colour of the message
message_font : str, optional
text font of the message
message_bold : bool, optional
True if message text should be bold
message_italic : bool, optional
True if message text should be italic
user_text_size : int, optional
text size of the user input
user_text_font : str, optional
text font of the user input
user_text_colour : (int, int ,int), optional
text colour of the user input
user_text_bold : bool, optional
True if user text should be bold
background_colour : (int, int, int), optional
frame_colour : (int, int, int)
colour of the frame
gap : int, optional
gap between message and user input
screen : io.Screen, optional
screen to present on
background_stimulus : visual Expyriment stimulus, optional
The background stimulus is a second stimulus that will be presented
together with the TextInput. For both stimuli overlap TextInput
will appear on top of the background_stimulus
"""
if not expyriment._active_exp.is_initialized:
raise RuntimeError(
"Cannot create TextInput before expyriment.initialize()!")
Input.__init__(self)
self._message = message
if position is not None:
self._position = position
else:
self._position = defaults.textinput_position
if ascii_filter is not None:
self._ascii_filter = ascii_filter
else:
self._ascii_filter = defaults.textinput_ascii_filter
if length is not None:
self._length = length
else:
self._length = defaults.textinput_length
if message_text_size is None:
message_text_size = defaults.textinput_message_text_size
if message_text_size is not None:
self._message_text_size = message_text_size
else:
self._message_text_size = expyriment._active_exp.text_size
if message_colour is None:
message_colour = defaults.textinput_message_colour
if message_colour is not None:
self._message_colour = message_colour
else:
self._message_colour = expyriment._active_exp.foreground_colour
if message_font is None:
message_font = defaults.textinput_message_font
if message_font is not None:
self._message_font = find_font(message_font)
else:
self._message_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(unicode2str(self._message_font, fse=True),
10)
except:
raise IOError("Font '{0}' not found!".format(message_font))
if message_bold is not None:
self._message_bold = message_bold
else:
self._message_bold = defaults.textinput_message_bold
if message_italic is not None:
self._message_italic = message_italic
else:
self._message_italic = defaults.textinput_message_italic
if user_text_size is None:
user_text_size = defaults.textinput_user_text_size
if user_text_size is not None:
self._user_text_size = user_text_size
else:
self._user_text_size = expyriment._active_exp.text_size
if user_text_bold is not None:
self._user_text_bold = user_text_bold
else:
self._user_text_bold = defaults.textinput_user_text_bold
if user_text_font is None:
user_text_font = defaults.textinput_user_text_font
if user_text_font is not None:
self._user_text_font = find_font(user_text_font)
else:
self._user_text_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(
unicode2str(self._user_text_font, fse=True), 10)
except:
raise IOError("Font '{0}' not found!".format(user_text_font))
if user_text_colour is None:
user_text_colour = defaults.textinput_user_text_colour
if user_text_colour is not None:
self._user_text_colour = user_text_colour
else:
self._user_text_colour = expyriment._active_exp.foreground_colour
if background_colour is None:
background_colour = \
defaults.textinput_background_colour
if background_colour is not None:
self._background_colour = background_colour
else:
self._background_colour = \
expyriment._active_exp.background_colour
if frame_colour is None:
frame_colour = defaults.textinput_frame_colour
if frame_colour is not None:
self._frame_colour = frame_colour
else:
self._frame_colour = expyriment._active_exp.foreground_colour
if gap is not None:
self._gap = gap
else:
self._gap = defaults.textinput_gap
if screen is not None:
self._screen = screen
else:
self._screen = expyriment._active_exp.screen
if background_stimulus is not None:
# FIXME child of child of visual does not work as background stimulus, e.g. BlankScreen
if background_stimulus.__class__.__base__ in \
[expyriment.stimuli._visual.Visual, expyriment.stimuli.Shape]:
self._background_stimulus = background_stimulus
else:
raise TypeError("{0} ".format(type(background_stimulus)) +
"is not a valid background stimulus. " +
"Use an expyriment visual stimulus.")
else:
self._background_stimulus = None
self._user = []
self._user_text_surface_size = None
self._max_size = None
self._message_surface_size = None
self._canvas = None
self._canvas_size = None
def __init__(self, heading, text, position=None, heading_font=None,
heading_size=None, heading_bold=None, heading_italic=None,
heading_underline=None, heading_colour=None, text_font=None,
text_size=None, text_bold=None, text_italic=None,
text_underline=None, text_colour=None,
text_justification=None, background_colour=None, size=None):
"""Create a text screen.
Parameters
----------
heading : str
heading of the text screen
text : str
text of the text screen
position : (int, int), optional
position of the stimulus
heading_font : str, optional
heading font to use
heading_size : int, optional
heading font size
heading_bold : bool, optional
heading should be bold
heading_italic : bool, optional
heading should be italic
heading_underline : bool, optional
heading should get an underline
heading_colour : (int,int,int), optional
heding colour
text_font : str, optional
text font to use
text_size : int, optional
text font size
text_bold : bool, optional
text should be bold
text_italic : bool, optional
text should be italic
text_underline : bool, optional
text should get an underline
text_colour : (int,int,int), optional
text colour
text_justification : int, optional
0 (Left), 1(center), 2(right) (int) (optional)
background_colour : (int, int, int), optional
background_colour
size : (int, int), optional
size of the text screen
"""
if position is None:
position = defaults.textscreen_position
Visual.__init__(self, position, log_comment="text_screen")
self._heading = heading
self._text = text
if heading_font is None:
heading_font = defaults.textscreen_heading_font
if heading_font is not None:
self._heading_font = find_font(heading_font)
else:
self._heading_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(
unicode2str(self._heading_font, fse=True), 10)
_font = None
except:
raise IOError("Font '{0}' not found!".format(heading_font))
if heading_size is None:
heading_size = defaults.textscreen_heading_size
if heading_size:
self._heading_size = heading_size
else:
self._heading_size = int(expyriment._active_exp.text_size
* 1.2)
if heading_bold is not None:
self._heading_bold = heading_bold
else:
self._heading_bold = defaults.textscreen_heading_bold
if heading_italic is not None:
self._heading_italic = heading_italic
else:
self._heading_italic = \
defaults.textscreen_heading_italic
if heading_underline is not None:
self._heading_underline = heading_underline
else:
self._heading_underline = \
defaults.textscreen_heading_underline
if heading_colour is None:
heading_colour = defaults.textscreen_heading_colour
if heading_colour is not None:
self._heading_colour = heading_colour
else:
self._heading_colour = expyriment._active_exp.foreground_colour
if text_font is None:
text_font = defaults.textscreen_text_font
if text_font is not None:
self._text_font = find_font(text_font)
else:
self._text_font = find_font(expyriment._active_exp.text_font)
try:
_font = pygame.font.Font(unicode2str(self._text_font, fse=True),
10)
_font = None
except:
raise IOError("Font '{0}' not found!".format(text_font))
if text_size is None:
self._text_size = defaults.textscreen_text_size
if text_size is not None:
self._text_size = text_size
else:
self._text_size = expyriment._active_exp.text_size
if text_bold is not None:
self._text_bold = text_bold
else:
self._text_bold = defaults.textscreen_text_bold
if text_italic is not None:
self._text_italic = text_italic
else:
self._text_italic = defaults.textscreen_text_italic
if text_underline is not None:
self._text_underline = text_underline
else:
self._text_underline = defaults.textscreen_text_underline
if text_colour is None:
text_colour = defaults.textscreen_text_colour
if text_colour is not None:
self._text_colour = text_colour
else:
self._text_colour = expyriment._active_exp.foreground_colour
if text_justification is not None:
self._text_justification = text_justification
else:
self._text_justification = \
defaults.textscreen_text_justification
if size is not None:
self._size = size
else:
size = defaults.textscreen_size
if size is None:
try:
self._size = (
expyriment._active_exp.screen.surface.get_size()[0] -
expyriment._active_exp.screen.surface.get_size()[0]
/ 5,
expyriment._active_exp.screen.surface.get_size()[1] -
expyriment._active_exp.screen.surface.get_size()[1]
/ 5)
except:
raise RuntimeError("Cannot get size of screen!")
if background_colour is not None:
self._background_colour = background_colour
else:
self._background_colour = \
defaults.textscreen_background_colour
