Beispiel #1
0
	def apply_script_changes(self, rebuild=True, catch=True):

		"""
		Apply changes to the script, by regenerating the item from the script

		Keywords arguments:
		rebuild -- specifies whether the overview area (item list) should be
				   rebuild (default=True)
		catch -- indicates if exceptions should be caught and shown in a
				 notification dialog (True) or not be caught (False)
				 (default=True)
		"""

		debug.msg(self.name)
		script = self.edit_script.edit.toPlainText()
		
		# Create a new item and make it a clone of the current item
		item = self.experiment.main_window.add_item(self.item_type, False, \
			name=self.name, interactive=False)
		if catch:
			try:
				self.experiment.items[item].from_string(script)
			except Exception as e:
				self.experiment.notify(unicode(e))
				return
		else:
			self.experiment.items[item].from_string(script)
		self.edit_script.setModified(False)
		self.experiment.items[item].name = self.name

		# Replace the current item
		self.experiment.items[self.name] = self.experiment.items[item]
		del self.experiment.items[item]
		self.experiment.items[self.name].init_script_widget()
		self.experiment.main_window.dispatch.event_script_change.emit(self.name)
Beispiel #2
0
	def apply_name_change(self, rebuild=True):

		"""
		Apply an item name change

		Keywords arguments:
		rebuild -- a deprecated argument (default=True)
		"""
		
		debug.msg()
		
		# Sanitize the name, check if it is new and valid, and if so, rename
		new_name = self.experiment.sanitize(self.header.edit_name.text(), \
			strict=True, allow_vars=False)
		if new_name.lower() == self.name.lower():
			self.header.edit_name.setText(self.name)
			return
		valid = self.experiment.check_name(new_name)
		if valid != True:
			self.experiment.notify(valid)
			self.header.edit_name.setText(self.name)
			return			
		old_name = self.name
		self.name = new_name
		self._edit_widget.__edit_item__	= new_name
		self.experiment.main_window.dispatch.event_name_change.emit(old_name, \
			new_name)
Beispiel #3
0
	def sanity_check(self):
	
		"""
		Checks whether all variables match prespecified criteria and fall back
		to the script editor otherwise. This is usefull to check that certain
		variables are numeric, etc.		
		"""

		debug.msg()		
		errors = []
		for var_name, criteria in self.sanity_criteria.items():
			msg = _("Invalid or missing value for variable '%s' (edit script to fix this)") \
				% var_name
			if 'msg' in criteria:
				msg += ': ' + criteria['msg']
			if not self.has(var_name) and 'required' in criteria and \
				criteria['required']:
				self.experiment.notify(msg)
				return False
			else:
				var = self.get(var_name, _eval=False)
				if 'type' in criteria:
					_type = criteria['type']
					if type(_type) != list:
						_type = [_type]
				 	if type(var) not in _type:
						self.experiment.notify(msg)
						return False
				if 'func' in criteria:
					if not criteria['func'](var):
						self.experiment.notify(msg)
						return False
		return True
Beispiel #4
0
	def set_cycle_count(self, cycles, confirm=True):

		"""
		Sets the nr of cycles and truncates data if necessary.

		Arguments:
		cycles		--	The number of cycles.

		Keyword arguments:
		confirm		--	Indicates whether confirmation is required before data
						is removed from the table. (default=True)
		"""

		if self.lock_cycles:
			return
		self.lock_cycles = True
		debug.msg(u"cycles = %s" % cycles)
		# Ask for confirmation before reducing the number of cycles.
		if len(self.matrix) > cycles and confirm:
			resp = QtGui.QMessageBox.question(self.experiment.ui.centralwidget,
				_(u"Remove cycles?"),
				_(u"By reducing the number of cycles, data will be lost from the table. Do you wish to continue?"),
				QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
			if resp == QtGui.QMessageBox.No:
				self.loop_widget.ui.spin_cycles.setValue(self.cycles)
				self.lock_cycles = False
				return
		for i in self.matrix.keys():
			if i >= cycles:
				del self.matrix[i]		
		self.lock_cycles = False
		self.set(u"cycles", cycles)
Beispiel #5
0
def load_mod(path, mod, pkg=None):

	"""
	Dynamically loads a module from a path.

	Arguments:
	path		--	A folder or file name. If a filename is specified, the
					file's directory will be used as path.
	mod			--	The name of a module, which corresponds to the name of the
					source file without the `.py` extension.
	pkg			--	The module's package. This is effectively a subfolder that
					is added to the path. (default=None)

	Returns:
	A Python module.
	"""

	import imp
	if isinstance(path, str):
		path = path.decode(sys.getfilesystemencoding())
	if not os.path.isdir(path):
		path = os.path.dirname(path)
	if pkg != None:
		path = os.path.join(path, pkg)
	path = os.path.join(path, mod+u'.py')
	debug.msg(u'loading module from %s' % path)
	return imp.load_source(mod, path)
Beispiel #6
0
def _color(color):

	"""
	See canvas.color()
	"""

	if type(color) in (str, unicode):
		return pygame.Color(str(color))
	elif type(color) == int:
		pygame.Color(color, color, color, 255)
	elif type(color) == float:
		i = int(255 * color)
		pygame.Color(i, i, i, 255)
	elif type(color) == tuple:
		if len(color) == 3:
			return pygame.Color(color[0], color[1], color[2], 255)
		elif len(color) > 3:
			return pygame.Color(color[0], color[1], color[2], color[3])
		else:
			return pygame.Color("white")
	elif type(color) == pygame.Color:
		return color
	else:
		debug.msg('Cannot interpret %s (%s), falling back to white' % (color, \
			type(color)))
		return pygame.Color("white")
Beispiel #7
0
	def setTheme(self):

		"""
		desc:
			Sets the theme, based on the QProgEdit settings.
		"""

		from QProgEdit import QColorScheme
		if not hasattr(QColorScheme, cfg.qProgEditColorScheme):
			debug.msg(u'Failed to set debug-output colorscheme')
			return u''
		cs = getattr(QColorScheme, cfg.qProgEditColorScheme)
		if not self.validTheme(cs):
			debug.msg(u'Invalid debug-output colorscheme')
			return u''
		self.control._highlighter.set_style(pygments_style_factory(cs))
		qss = u'''QPlainTextEdit, QTextEdit {
				background-color: %(Background)s;
				color: %(Default)s;
			}
			.in-prompt { color: %(Prompt in)s; }
			.in-prompt-number { font-weight: bold; }
			.out-prompt { color: %(Prompt out)s; }
			.out-prompt-number { font-weight: bold; }
			''' % cs
		self.control.style_sheet = qss
		self.control._control.setFont(QtGui.QFont(cfg.qProgEditFontFamily,
			cfg.qProgEditFontSize))
Beispiel #8
0
	def parse_cmdline_args(self, args):

		"""
		Apply settings that were specified on the command line. The expected
		format is as follows: [name]=[val];[name]=[val];...

		Arguments:
		args -- the string of command line arguments
		"""

		if args is None:
			return
		for arg in args.split(u";"):
			a = arg.split(u"=")
			if len(a) == 2:
				# Automagically determine the data type
				if a[1] == u"True":
					val = True
				elif a[1] == u"False":
					val = False
				else:
					try:
						val = int(a[1])
					except:
						try:
							val = float(a[1])
						except:
							val = a[1]
				# Apply the argument
				try:
					self.__setattr__(a[0], val)
					debug.msg(u"%s = %s" % (a[0], val))
				except:
					debug.msg(u"Failed to parse argument: %s" % arg)
Beispiel #9
0
	def event_startup(self):

		"""
		desc:
			Initializes the extension on OpenSesame startup.
		"""

		# Create the autosave folder if it doesn't exist yet
		if not os.path.exists(os.path.join(self.main_window.home_folder,
			u".opensesame", u"backup")):
			os.mkdir(os.path.join(self.main_window.home_folder, u".opensesame",
				u"backup"))
		self.autosave_folder = os.path.join(self.main_window.home_folder,
			u".opensesame", u"backup")

		# Remove expired backups
		for path in os.listdir(self.autosave_folder):
			_path = os.path.join(self.autosave_folder, path)
			t = os.path.getctime(_path)
			age = (time.time() - t)/(60*60*24)
			if age > cfg.autosave_max_age:
				debug.msg(u"removing '%s'" % path)
				try:
					os.remove(_path)
				except:
					debug.msg(u"failed to remove '%s'" % path)

		self.start_autosave_timer()
Beispiel #10
0
	def add(self, files):

		"""
		Add a list of files to the pool.

		Arguments:
		files - A list of paths
		"""

		basename = ""
		for path in files:
			path = unicode(path)
			debug.msg(path)
			basename = os.path.basename(path)
			if not os.path.isfile(path):
				self.main_window.experiment.notify( \
					"'%s' is not a regular file and could not be added to the file pool." \
					% path)
			else:
				# If a similar file already exists in the pool, ask before overwriting
				if os.path.exists(os.path.join( \
					self.main_window.experiment.pool_folder, basename)):
					resp = QtGui.QMessageBox.question(self, _("Overwrite"), \
						_("A file named '%s' already exists in the pool. Do you want to overwrite this file?") \
						% basename, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
					if resp == QtGui.QMessageBox.Yes:
						shutil.copyfile(path, os.path.join( \
							self.main_window.experiment.pool_folder, basename))
				else:
					shutil.copyfile(path, os.path.join( \
						self.main_window.experiment.pool_folder, basename))

		self.refresh()
		self.select(basename)
Beispiel #11
0
def change_working_dir():

	"""A horrifyingly ugly hack to change the working directory under Windows"""

	import libqtopensesame.qtopensesame

	if os.name == "nt":
		try:
			# Extract the part of the description containing the path
			s = unicode(libqtopensesame.qtopensesame)
			i = s.find("from '") + 6
			j = s.find("'>'") - 1
			s = s[i:j]
			# Go up the tree until the path of the current script
			while not os.path.exists(os.path.join(s, "opensesame")) and \
				not os.path.exists(os.path.join(s, "opensesame.exe"))and \
				not os.path.exists(os.path.join(s, "opensesamerun")) and \
				not os.path.exists(os.path.join(s, "opensesamerun.exe")):
				s = os.path.dirname(s)
			os.chdir(s)
			if s not in sys.path:
				sys.path.append(s)
			debug.msg(s)
		except Exception as e:
			debug.msg("failed to change working directory: %s" % e)
Beispiel #12
0
	def qicon(self, icon):

		"""
		Get an icon from the theme

		Arguments:
		icon -- the icon name

		Returns:
		A QIcon
		"""

		if isinstance(icon, QtGui.QIcon):
			return icon
		if hasattr(self, u'experiment') and u'%s_large.png' % icon in \
			self.experiment.resources:
			return QtGui.QIcon(self.experiment.resource(u'%s_large.png' % icon))
		if icon in self.icon_map:
			name = self.icon_map[icon][0]
		else:
			name = icon
		icon = QtGui.QIcon.fromTheme(name, self.fallback_icon)
		if icon.name() != name:
			debug.msg(u'missing icon %s' % name, reason=u'warning')
		return icon
Beispiel #13
0
	def __init__(self, sketchpad, string, defaults=[]):

		"""
		desc:
			Constructor.

		arguments:
			sketchpad:		A sketchpad object.
			string:			A definition string.

		keywords:
			defaults:		A list with (name, default_value) tuples for all
							keywords.
		"""

		self._type = self.__class__.__name__
		# These keywords provide compatibility with older versions of
		# OpenSesame. `only_keywords` specifies whether all parameters should be
		# written as keywords, which will prevent < 2.9.0 from reading the
		# sketchpad elements. If not, keywords with a None default will be
		# written value-only style. `fix_coordinates` specifies whether
		# coordinates should be translated to top-left = 0,0.
		self.only_keywords = False
		self.fix_coordinates = sketchpad.var.uniform_coordinates!=u'yes'
		debug.msg(self._type)
		self.defaults = defaults + [
			(u'z_index', 0),
			(u'show_if', u'always')
			]
		self.sketchpad = sketchpad
		self.var = self.sketchpad.var
		self.from_string(string)
Beispiel #14
0
	def suggest_variables(self):

		"""
		Smart select all variables that should probably be logged. Variables in
		unused items are ignored.
		"""

		i = 0
		for item in self.experiment.items:
			if item in self.experiment.unused_items:
				debug.msg("ignoring variables from '%s'" % item)
				continue
			if self.experiment.items[item].item_type in ("loop", \
				"keyboard_response", "mouse_response"):
				for var, val in self.experiment.items[item].var_info():
					if var not in self.logvars and var != "time_%s" % item and \
						var != "count_%s" % item:
						self.logvars.append(var)
			if self.experiment.items[item].item_type == "sequence":
				for var, val in self.experiment.items[item].var_info():
					if var not in self.logvars and var == "count_%s" % item:
						self.logvars.append(var)

		self.edit_widget()
		self.experiment.main_window.refresh(self.name)
Beispiel #15
0
	def run(self):

		"""
		desc:
			Runs the item.
		"""

		# Set the onset time
		self.set_item_onset()
		# Flush keyboard, so the escape key can be used
		self._keyboard.flush()
		# If no start response interval has been set, set it to the onset of
		# the current response item
		if self.experiment._start_response_interval is None:
			self.experiment._start_response_interval = self.var.get(
				u'time_%s' % self.name)
		if self.var._dummy == u'yes':
			# In dummy mode, no one can hear you scream! Oh, and we simply
			# take input from the keyboard
			resp, self.experiment.end_response_interval = self._resp_func(
				keylist=None, timeout=self._timeout)
		else:
			# Get the response
			resp, self.experiment.end_response_interval = self._resp_func(
				self._allowed_responses, self._timeout)
		debug.msg(u'received %s' % resp)
		self.experiment.var.response = resp
		generic_response.generic_response.response_bookkeeping(self)
Beispiel #16
0
	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
Beispiel #17
0
	def prepare(self):

		"""The preparation phase of the plug-in."""

		item.item.prepare(self)
		# Sanity check on the duration value, which should be a positive numeric
		# value.
		if type(self.get('duration')) not in (int, float) or \
			self.get('duration') < 0:
			raise osexception( \
				u'Duration should be a positive numeric value in advanced_delay %s' \
				% self.name)
		if self.get(u'jitter_mode') == u'Uniform':
			self._duration = random.uniform(self.get(u'duration')-self.get( \
				u'jitter')/2, self.get(u'duration')+self.get(u'jitter')/2)
		elif self.get(u'jitter_mode') == u'Std. Dev.':
			self._duration = random.gauss(self.get(u'duration'), self.get( \
				u'jitter'))
		else:
			raise osexception( \
				u'Unknown jitter mode in advanced_delay %s' % self.name)
		# Don't allow negative durations.
		if self._duration < 0:
			self._duration = 0
		self._duration = int(self._duration)
		self.experiment.set(u'delay_%s' % self.name, self._duration)
		debug.msg(u"delay for %s ms" % self._duration)
	def auto_responder(self, dev=u'keyboard'):

		"""
		Mimicks participant responses.

		Keyword arguments:
		dev		--	The device that should be simulated. (default=u'keyboard')

		Returns:
		A simulated (response_time, response) tuple
		"""

		if self._timeout == None:
			self.sleep(random.randint(200, 1000))
		else:
			self.sleep(random.randint(min(self._timeout, 200), self._timeout))

		if self._allowed_responses == None:
			resp = self.auto_response
		else:
			resp = random.choice(self._allowed_responses)

		debug.msg(u"generic_response.auto_responder(): responding '%s'" % resp)
		if dev == u'mouse':
			pos = random.randint(0, self.get(u'width')), random.randint( \
				0, self.get(u'height'))
			return resp, pos, self.time()
		return resp, self.time()
Beispiel #19
0
	def delete_selected_files(self):

		"""
		desc:
			Deletes all selected files from the pool. Asks for confimation\
			first.
		"""

		# Prepare the confirmation dialog, which contains a limited nr of
		# filenames
		l = []
		suffix = u''
		for item in self.ui.list_pool.selectedItems()[:self.max_len]:
			l.append(self.pool[item.text()])
		if len(self.ui.list_pool.selectedItems()) > self.max_len:
			suffix = _('And %d more file(s)') % \
				(len(self.ui.list_pool.selectedItems())-self.max_len)
		msg = _(u"<p>Are you sure you want to remove the following files?</p>"
			u"<p>- %s</p> <p>%s</p>") % (u"<br /> - ".join(l), suffix)
		c = confirmation(self.main_window, msg)
		if not c.show():
			return
		# Create a list of files to be removed
		dL = []
		for item in self.ui.list_pool.selectedItems():
			dL.append(item.path)
		# Remove the files
		try:
			for f in dL:
				del self.pool[f]
			debug.msg(u"removed '%s'" % f)
		except:
			debug.msg(u"failed to remove '%s'" % f)
		self.refresh()
		self.main_window.set_unsaved()
Beispiel #20
0
	def __init__(self, main_window, theme=None):
	
		"""
		Constructor
		
		Arguments:
		main_window -- the main_window object
		
		Keyword arguments:
		theme -- the theme to be used or None to use config (default=None)
		"""

		self.main_window = main_window
		if theme == None:
			self.theme = config.get_config(u"theme")
		else:
			self.theme = theme
		self.theme_folder = misc.resource(os.path.join(u"theme", \
			self.theme))
		debug.msg(u"theme = '%s' (%s)" % (self.theme, self.theme_folder))			
		if self.theme_folder == None or not os.path.exists(self.theme_folder):			
			debug.msg(u"theme '%s' does not exist, using 'default'" % theme, \
				reason=u"warning")
			self.theme = u"default"
			self.theme_folder = misc.resource(os.path.join(u"theme", \
				self.theme))						
		self.theme_info = os.path.join(self.theme_folder, u"__theme__.py")
		if os.path.exists(self.theme_info):						
			info = imp.load_source(self.theme, self.theme_info)
			self._qss = path = \
				open(os.path.join(self.theme_folder, info.qss)).read()
			self._icon_map = info.icon_map
			self._icon_theme = info.icon_theme									
		self.load_icon_map()
		self.apply_theme(self.main_window)			
Beispiel #21
0
	def auto_add_widget(self, widget, var=None):

		"""
		Add a widget to the list of auto-widgets

		Arguments:
		widget -- a QWidget

		Keyword arguments:
		var -- the variable to be linked to the widget (default=None)
		"""

		# Use the object id as a fallback name
		if var == None:
			var = id(widget)
		debug.msg(var)
		self.set_focus_widget(widget)
		if isinstance(widget, QtGui.QSpinBox) or isinstance(widget,
			QtGui.QDoubleSpinBox):
			widget.editingFinished.connect(self.apply_edit_changes)
			self.auto_spinbox[var] = widget
		elif isinstance(widget, QtGui.QComboBox):
			widget.activated.connect(self.apply_edit_changes)
			self.auto_combobox[var] = widget
		elif isinstance(widget, QtGui.QSlider):
			widget.editingFinished.connect(self.apply_edit_changes)
			self.auto_slider[var] = widget
		elif isinstance(widget, QtGui.QLineEdit):
			widget.editingFinished.connect(self.apply_edit_changes)
			self.auto_line_edit[var] = widget
		elif isinstance(widget, QtGui.QCheckBox):
			widget.clicked.connect(self.apply_edit_changes)
			self.auto_checkbox[var] = widget
		else:
			raise Exception(u"Cannot auto-add widget of type %s" % widget)
Beispiel #22
0
    def image(self, fname, center=True, x=None, y=None, scale=None):

        _fname = safe_str(fname, enc=misc.filesystem_encoding())
        if not os.path.isfile(_fname):
            raise osexception(u'"%s" does not exist' % fname)
        try:
            surface = pygame.image.load(_fname)
        except pygame.error:
            raise osexception(u"'%s' is not a supported image format" % fname)
        if scale is not None:
            try:
                surface = pygame.transform.smoothscale(
                    surface, (int(surface.get_width() * scale), int(surface.get_height() * scale))
                )
            except:
                debug.msg(u"smooth scaling failed for '%s'" % fname, reason=u"warning")
                surface = pygame.transform.scale(
                    surface, (int(surface.get_width() * scale), int(surface.get_height() * scale))
                )
        size = surface.get_size()
        x, y = self.to_xy(x, y)
        if center:
            x -= size[0] / 2
            y -= size[1] / 2
        self.surface.blit(surface, (x, y))
Beispiel #23
0
	def load_ui(self, ui=None):

		"""
		desc:
			Dynamically loads the ui, if any.

		keywords:
			ui:			An id for a user-interface file, or None.
		"""

		if ui is not None:
			# If the UI file has been explicitly registered, which is the case
			# for extensions
			if hasattr(self, u'experiment') and ui in self.experiment.resources:
				ui_path = self.experiment.resources[ui]
			else:
				# Dot-split the ui id, append a `.ui` extension, and assume it's
				# relative to the resources/ui subfolder.
				path_list = [u'ui'] + ui.split(u'.')
				if hasattr(self, u'experiment'):
					# If an experiment object is available, use that to find the
					# resources ...
					ui_path = self.experiment.resource(
						os.path.join(*path_list)+u'.ui')
				else:
					# ... otherwise use the static resources function.
					from libopensesame import misc
					ui_path = misc.resource(os.path.join(*path_list)+u'.ui')
			debug.msg(u'dynamically loading ui: %s' % ui_path)
			with open(ui_path) as fd:
				self.ui = uic.loadUi(fd, self)
		else:
			self.ui = None
	def reset(self):

		"""
		desc:
			Initialize/ reset the plug-in.
		"""

		self.file_loaded = False
		self.resizeVideo = u"yes"
		self.duration = u"keypress"
		self.playaudio = u"yes"
		self.sendInfoToEyelink = u"no"
		self.event_handler = u""
		self.event_handler_trigger = u"on keypress"
		self.vlc_event_handler = None

		self.media = None
		self.framerate = 0
		self.frame_duration = 0
		self.startPlaybackTime = 0
		self.playbackStarted = False
		self.hasMediaInfo = False

		#See if MediaInfo functions are available
		try:
			MediaInfo.parse(u"")
			self.hasMediaInfo = True
		except:
			debug.msg( \
				u"MediaInfo CLI not found. Frame info might be unavailable.",
				reason=u"warning")
			self.hasMediaInfo = False
Beispiel #25
0
	def parse_definition(self, item_type, item_name, string):

		"""
		Initializes a single definition, using the string, and adds it to the
		dictionary of items.

		Arguments:
		item_type	--	The item's type.
		item_name	--	The item's name.
		string		--	The item's definition string.
		"""

		if plugins.is_plugin(item_type):
			# Load a plug-in
			try:
				item = plugins.load_plugin(item_type, item_name, self, \
					string, self.item_prefix())
			except Exception as e:
				raise osexception(u"Failed to load plugin '%s'" % \
					item_type, exception=e)
			self.items[item_name] = item
		else:
			# Load one of the core items
			debug.msg(u"loading core item '%s' from '%s'" % (item_type, \
				self.module_container()))
			item_module = __import__(u'%s.%s' % (self.module_container(), \
				item_type), fromlist=[u'dummy'])
			item_class = getattr(item_module, item_type)
			item = item_class(item_name, self, string)
			self.items[item_name] = item
Beispiel #26
0
	def edit_widget(self):

		"""Set the loop controls from the variables"""

		self.lock = True
		debug.msg()			
		# Update the item combobox
		self.experiment.item_combobox(self.item, self.parents(), \
			self.loop_widget.ui.combobox_item)
		qtitem.qtitem.edit_widget(self)
		self.refresh_loop_table(lock=False)		
		self.loop_widget.ui.spin_cycles.setValue(self.cycle_count())
		
		if self.get("order") == "random":
			self.loop_widget.ui.label_skip.setDisabled(True)
			self.loop_widget.ui.spin_skip.setDisabled(True)
			self.loop_widget.ui.checkbox_offset.setDisabled(True)
		else:
			self.loop_widget.ui.label_skip.setDisabled(False)
			self.loop_widget.ui.spin_skip.setDisabled(False)
			self.loop_widget.ui.checkbox_offset.setDisabled( \
				self.get("skip") < 1)
		self.refresh_summary()
		self.lock = False
		return self._edit_widget
Beispiel #27
0
	def from_string(self, string):

		"""
		Reads the entire experiment from a string.

		Arguments:
		string	--	The definition string.
		"""

		debug.msg(u"building experiment")
		s = iter(string.split("\n"));
		line = next(s, None)
		while line != None:
			get_next = True
			try:
				l = self.split(line)
			except ValueError as e:
				raise osexception( \
					u"Failed to parse script. Maybe it contains illegal characters or unclosed quotes?", \
					exception=e)
			if len(l) > 0:
				self.parse_variable(line)
				# Parse definitions
				if l[0] == u"define":
					if len(l) != 3:
						raise osexception( \
							u'Failed to parse definition', line=line)
					item_type = l[1]
					item_name = self.sanitize(l[2])
					line, def_str = self.read_definition(s)
					get_next = False
					self.parse_definition(item_type, item_name, def_str)
			# Advance to next line
			if get_next:
				line = next(s, None)
Beispiel #28
0
    def run(self):

        """The run phase of the plug-in goes here."""
        if self.get(u"auto_log") == u"yes":
            # Log everything
            self.logvars = []
            for logvar, val, item in self.experiment.var_list():
                if (self.has(logvar) or self.get(u"ignore_missing") == u"yes") and logvar not in self.logvars:
                    self.logvars.append(logvar)
                    debug.msg(u'auto-logging "%s"' % logvar)
        else:
            # Parse variable to log from user input (stopgap function, until
            # proper UI can be used.
            self.logvars = self._vars_string.strip(" ").split("\n")

        trial_data = dict()
        for var in self.logvars:
            try:
                val = self.experiment.get(var)
            except exceptions.runtime_error as e:
                if self.get(u"ignore_missing") == u"yes":
                    val = u"NA"
                else:
                    raise exceptions.runtime_error(
                        u"Logger '%s' tries to log the variable '%s', but this variable is not available. Please deselect '%s' in logger '%s' or enable the 'Use NA for variables that have not been set' option."
                        % (self.name, var, var, self.name)
                    )
            trial_data[var] = val

        self.experiment.log_list.append(trial_data)
	def closePlayer(self):
		self.player.release()
		self.vlcInstance.release()
		self.media = None
		debug.msg("Released VLC modules")
		if hasattr(self, "screen"):
			self.screen = None
Beispiel #30
0
	def handle_starttag(self, tag, attrs):

		"""
		Handle an opening tag

		Arguments:
		tag -- the closing tag
		attrs -- the tag attributes
		"""

		if tag not in self.valid_start_tags:
			return

		if tag == u'br':
			self.text.append(self.paragraph)
			self.paragraph = []
			return

		self.current_tag = tag

		if tag == u'span':
			style = {}
			for var, val in attrs:
				style[str(var)] = val
			self.push_style(**style)
		elif tag == u'b':
			self.push_style(bold=True)
		elif tag == u'i':
			self.push_style(italic=True)
		elif tag == u'u':
			self.push_style(underline=True)
		else:
			debug.msg(u'Unrecognized tag: %s' % tag)
Beispiel #31
0
    def from_string(self, string):
        """
		Parses the item from a definition string.

		Arguments:
		string	--	The definition string.
		"""

        debug.msg()
        textblock_var = None
        self.variables = {}
        self.reset()
        self.comments = []
        for line in string.split(u'\n'):
            line_stripped = line.strip()
            # The end of a textblock
            if line_stripped == u'__end__':
                if textblock_var == None:
                    self.experiment.notify( \
                     u'It appears that a textblock has been closed without being opened. The most likely reason is that you have used the string "__end__", which has a special meaning for OpenSesame.')
                else:
                    self.set(textblock_var, textblock_val)
                    textblock_var = None
            # The beginning of a textblock. A new textblock is only started when
            # a textblock is not already ongoing, and only if the textblock
            # start is of the format __VARNAME__
            elif line_stripped[:2] == u'__' and line_stripped[-2:] == u'__' \
             and textblock_var == None:
                textblock_var = line_stripped[2:-2]
                if textblock_var in self.reserved_words:
                    textblock_var = u'_' + textblock_var
                if textblock_var != u'':
                    textblock_val = u''
                else:
                    textblock_var = None
                # We cannot just strip the multiline code, because that may mess
                # up indentation. So we have to detect if the string is indented
                # based on the opening __varname__ line.
                strip_tab = line[0] == u'\t'
            # Collect the contents of a textblock
            elif textblock_var != None:
                if strip_tab:
                    textblock_val += line[1:] + u'\n'
                else:
                    textblock_val += line + u'\n'
            # Parse regular variables
            elif not self.parse_variable(line):
                self.parse_line(line)
Beispiel #32
0
    def update_resolution(self, width, height):
        """
		desc:
			Updates the resolution in a way that preserves display centering.
			This is kind of a quick hack. First generate the script, change the
			resolution in the script and then re-parse the script.

		arguments:
			width:		The display width in pixels.
			height:		The display height in pixels.
		"""

        debug.msg(u"changing resolution to %d x %d" % (width, height))
        try:
            script = self.experiment.to_string()
        except Exception as e:
            if not isinstance(e, osexception):
                e = osexception(u'Failed to change the display resolution',
                                exception=e)
            md = _(u'# Error\n\nFailed to change display resolution for the '
                   u'following reason:\n\n- ') + e.markdown()
            self.tabwidget.open_markdown(md)
            return
        old_cmd = self.experiment.syntax.create_cmd(
            u'set', [u'height', self.experiment.var.height])
        new_cmd = self.experiment.syntax.create_cmd(u'set',
                                                    [u'height', height])
        script = script.replace(old_cmd, new_cmd)
        old_cmd = self.experiment.syntax.create_cmd(
            u'set', [u'width', self.experiment.var.width])
        new_cmd = self.experiment.syntax.create_cmd(u'set', [u'width', width])
        script = script.replace(old_cmd, new_cmd)
        try:
            tmp = experiment.experiment(
                self,
                name=self.experiment.var.title,
                string=script,
                pool_folder=self.experiment.pool.folder(),
                experiment_path=self.experiment.experiment_path,
                resources=self.experiment.resources)
        except osexception as error:
            self.experiment.notify(_(u"Could not parse script: %s") % error)
            self.edit_script.edit.setText(self.experiment.to_string())
            return
        self.experiment = tmp
        self.ui.tabwidget.close_other()
        self.update_overview_area()
        self.extension_manager.fire(u'regenerate')
Beispiel #33
0
    def open_edit_tab(self, index=None, focus=True):
        """
		Opens/ shows the GUI control tab

		Keywords arguments:
		index -- the index of the tab (if it is already open) (default=None)
		focus -- indicates whether the tab should receive focus (default=True)
		"""

        debug.msg("%s (#%s)" % (self.name, hash(self)))

        # Switch to edit mode and close the script tab if it was open
        self.edit_mode = "edit"
        for i in range(self.experiment.ui.tabwidget.count()):
            w = self.experiment.ui.tabwidget.widget(i)
            if hasattr(w, "script_item") and w.script_item == self.name:
                self.experiment.ui.tabwidget.removeTab(i)
                if index == None:
                    index = i
                break

        # Focus the edit tab, instead of reopening, if it was already open
        for i in range(self.experiment.ui.tabwidget.count()):
            w = self.experiment.ui.tabwidget.widget(i)
            if hasattr(w, "edit_item") and w.edit_item == self.name:
                index = i

        # Refresh the controls on the tab. In debug mode don't catch any errors
        if debug.enabled:
            widget = self.edit_widget()
        else:
            try:
                widget = self.edit_widget()
            except Exception as e:
                self.experiment.notify("%s (Edit the script to fix this)" % e)
                self.open_script_tab()
                return

        # Open the tab or focus the tab if it was already open
        if index == None:
            self.edit_tab_index = self.experiment.ui.tabwidget.addTab(widget, \
             self.experiment.icon(self.item_type), "%s" % self.name)
        else:
            self.experiment.ui.tabwidget.insertTab(index, widget, \
             self.experiment.icon(self.item_type), "%s" % self.name)
            self.edit_tab_index = index
        if focus:
            self.experiment.ui.tabwidget.setCurrentIndex(self.edit_tab_index)
Beispiel #34
0
    def auto_apply_edit_changes(self, rebuild=True):
        """
		Apply the auto-widget controls

		Keyword arguments:
		rebuild -- deprecated (does nothing) (default=True)
		"""

        debug.msg()
        for var, edit in self.auto_line_edit.iteritems():
            if type(var) == str:
                val = unicode(edit.text()).strip()
                if val != "":
                    self.set(var, val)

                # If the variable has no value, we assign a default value if it
                # has been specified, and unset it otherwise.
                elif hasattr(edit, "default"):
                    self.set(var, edit.default)
                else:
                    self.unset(var)

        for var, combobox in self.auto_combobox.iteritems():
            if type(var) == str:
                self.set(var, unicode(combobox.currentText()))

        for var, spinbox in self.auto_spinbox.iteritems():
            if type(var) == str:
                self.set(var, spinbox.value())

        for var, slider in self.auto_slider.iteritems():
            if type(var) == str:
                self.set(var, slider.value())

        for var, checkbox in self.auto_checkbox.iteritems():
            if type(var) == str:
                if checkbox.isChecked():
                    val = "yes"
                else:
                    val = "no"
                self.set(var, val)

        for var, editor in self.auto_editor.iteritems():
            if type(var) == str:
                self.set(var, editor.edit.toPlainText())
                editor.setModified(False)

        return True
Beispiel #35
0
def plugin_property(plugin, _property, default=0):
    """
	Returns a property of a plug-in.

	Arguments:
	plugin		--	The name of the plugin.
	_property	--	The name of the property.

	Keywords arguments:
	default		--	A default property value. (default=0)

	Returns:
	The property value.
	"""

    global _properties
    if plugin in _properties and _property in _properties[plugin]:
        return _properties[plugin][_property]
    if plugin not in _properties:
        _properties[plugin] = {}
    info_txt = os.path.join(plugin_folder(plugin), u'info.txt')
    info_json = os.path.join(plugin_folder(plugin), u'info.json')
    # New-style plug-ins, using info.json
    if os.path.exists(info_json):
        try:
            _json = json.load(open(info_json))
        except:
            debug.msg(u'Failed to parse %s' % info_json)
            _json = {}
        if _property in _json:
            return _json[_property]
    # Old-style plug-ins, using info.txt
    elif os.path.exists(info_txt):
        for l in open(info_txt, u'r'):
            a = l.split(":")
            if len(a) == 2 and a[0] == _property:
                val = a[1].strip()
                try:
                    val = int(val)
                finally:
                    _properties[plugin][_property] = val
                    return val
        _properties[plugin][_property] = default
    else:
        debug.msg( \
         u'Failed to read plug-in information (%s) from info.[txt|json]' \
         % plugin)
    return default
Beispiel #36
0
    def prepare(self):
        """Prepares the item."""

        # Pass the word on to the parent
        item.item.prepare(self)

        # 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() != "":
                    try:
                        r = int(r)
                    except:
                        raise osexception( \
                         u"'%s' is not a valid response on your joystick/gamepad. Expecting a number in the range of 1 to the amount of buttons." \
                         % (r,self.name))
                    if r < 0 or r > 255:
                        raise osexception( \
                         u"'%s' is not a valid response on your joystick/gamepad. Expecting a number in the range of 1 to the amount of buttons." \
                         % (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 has been set to %s" %
                  self._allowed_responses)
        # In case of dummy-mode:
        self._keyboard = openexp.keyboard.keyboard(self.experiment)
        if self.has(u"_dummy") and self.get(u"_dummy") == u"yes":
            self._resp_func = self._keyboard.get_key
        # Not in dummy-mode:
        else:
            timeout = self.get(u"timeout")
            # Dynamically load a joystick instance
            if not hasattr(self.experiment, u"joystick"):
                path = os.path.join(os.path.dirname(__file__), \
                 u"libjoystick.py")
                _joystick = imp.load_source(u"libjoystick", path)
                self.experiment.joystick = _joystick.libjoystick( \
                 self.experiment)
            # Prepare auto response
            if self.experiment.auto_response:
                self._resp_func = self.auto_responder
            else:
                self._resp_func = self.experiment.joystick.get_joybutton
        self.prepare_timeout()
Beispiel #37
0
    def event_rename_item(self, from_name, to_name):
        """
		desc:
			Called after an item has been renamed.

		arguments:
			from_name:
				desc:	The old name.
				type:	unicode
			to_name:
				desc:	The new name.
				type:	unicode
		"""

        debug.msg(u'Event fired: rename_item(from_name=%s, to_name=%s)' \
         % (from_name, to_name))
Beispiel #38
0
	def get_ready(self):

		"""
		desc:
			Applies pending script changes.

		returns:
			True if changes have been made, False otherwise.
		"""

		for var, qprogedit in self.auto_editor.items():
			if qprogedit.isAnyModified():
				debug.msg(u'applying pending editor changes')
				self.apply_edit_changes()
				return True
		return qtitem.qtitem.get_ready(self)
Beispiel #39
0
	def set_validator(self):

		"""
		desc:
			Sets the validator class, that is, the class that is used to parse
			scripts to see if they are syntactically correct. Currently, we use
			the class that defines from_string().
		"""

		import inspect
		meth = self.from_string
		for cls in inspect.getmro(self.__class__):
			if meth.__name__ in cls.__dict__:
				break
		debug.msg(u'validator: %s' % cls)
		self.validator = cls
Beispiel #40
0
    def get_ready(self):
        """Give all items the opportunity to get ready for running or saving"""

        # Redo the get_ready loop until no items report having done
        # anything
        redo = True
        done = []
        while redo:
            redo = False
            for item in self.experiment.items:
                if item not in done:
                    done.append(item)
                    if self.experiment.items[item].get_ready():
                        debug.msg(u"'%s' did something" % item)
                        redo = True
                        break
Beispiel #41
0
    def load_icons(self, ui):
        """
		Add icons to all icon supporting widgets in a ui object
				
		Arguments:
		ui -- the ui object to load icons into
		"""

        debug.msg()
        for i in dir(ui):
            if i in self.icon_map:
                a = getattr(ui, i)
                if hasattr(a, u"setIcon"):
                    a.setIcon(self.qicon(i))
                elif hasattr(a, u"setPixmap"):
                    a.setPixmap(self.qpixmap(i))
Beispiel #42
0
	def __init__(self):

		"""Constructor"""

		# The auto-widgets are stored in name -> (var, widget) dictionaries
		self.auto_line_edit = {}
		self.auto_combobox = {}
		self.auto_spinbox = {}
		self.auto_slider = {}
		self.auto_editor = {}
		self.auto_checkbox = {}
		self.init_edit_widget()
		self.lock = False
		self.maximized = False
		self.set_validator()
		debug.msg(u'created %s' % self.name)
Beispiel #43
0
	def get_ready(self):

		"""
		Apply pending script changes

		Returns:
		True if changes have been made, False otherwise
		"""

		for var, editor in self.auto_editor.iteritems():
			if editor.isModified():
				debug.msg("applying pending Python script changes")
				self.apply_edit_changes()
				return True

		return qtitem.qtitem.get_ready(self)
Beispiel #44
0
    def start_autosave_timer(self):
        """
		desc:
			Starts the autosave timer.
		"""

        if cfg.autosave_interval > 0:
            debug.msg(u"autosave interval = %d ms" % cfg.autosave_interval)
            self.autosave_timer = QtCore.QTimer()
            self.autosave_timer.setInterval(cfg.autosave_interval)
            self.autosave_timer.setSingleShot(True)
            self.autosave_timer.timeout.connect(self.autosave)
            self.autosave_timer.start()
        else:
            debug.msg(u"autosave disabled")
            self.autosave_timer = None
Beispiel #45
0
def register_font(font_path):
    """
	desc:
		Register a font with PyGlet. If the font has already been registered,
		this function does nothing.

	arguments:
		font_path:	The full path to the font file.
	"""

    global _registered_fonts
    if font_path in _registered_fonts:
        return
    debug.msg(u'registering %s' % font_path)
    pyglet.font.add_file(font_path)
    _registered_fonts.append(font_path)
Beispiel #46
0
    def handle_endtag(self, tag):
        """
		Handle a closing tag

		Arguments:
		tag -- the closing tag
		"""

        if tag not in self.valid_end_tags:
            return

        if self.current_tag != tag:
            debug.msg(u'Warning: expecting closing tag for %s, got %s' % \
             (self.current_tag, tag), reason=u'warning')

        self.pop_style()
Beispiel #47
0
    def edit_widget(self, stretch=True):
        """
		A dummy edit widget, to be overridden

		Keywords arguments:
		stretch -- a deprecated argument (default=True)
		"""

        if not stretch:
            debug.msg("passing the stretch argument is deprecated", \
             reason="deprecation")
        self.header.restore_name(False)
        self.header.refresh()
        self._edit_widget.edit_item = self.name
        self.auto_edit_widget()
        return self._edit_widget
Beispiel #48
0
	def qicon(self, icon):

		"""
		desc:
			Gets an icon from the theme.

		arguments:
			icon:	One of the following:
					- A QIcon, which returned as is
					- The name of an image file
					- The name of a plug-in with a hardcoded icon
					- The name of an entry in the icon map
					- A theme icon name.

		returns:
			desc:	An icon, or a fallback icon if the specified wasn't found.
			type:	QIcon
		"""

		if isinstance(icon, QtGui.QIcon):
			return icon
		if os.path.isfile(icon):
			qicon = QtGui.QIcon()
			if icon.endswith(u'_large.png'):
				size = 32
			else:
				size = 16
			qicon.addFile(icon, size=QtCore.QSize(size, size))
			return qicon
		if hasattr(self, u'experiment') and (u'%s_large.png' % icon in \
			self.experiment.resources or '%s.png' in self.experiment.resources):
			qicon = QtGui.QIcon()
			if u'%s_large.png' % icon in self.experiment.resources:
				qicon.addFile(self.experiment.resource(
					u'%s_large.png' % icon), size=QtCore.QSize(32,32))
			if u'%s.png' % icon in self.experiment.resources:
				qicon.addFile(self.experiment.resource(u'%s.png' % icon),
					size=QtCore.QSize(16,16))
			return qicon
		if icon in self.icon_map:
			name = self.icon_map[icon][0]
		else:
			name = icon
		icon = QtGui.QIcon.fromTheme(name, self.fallback_icon)
		if icon.name() != name:
			debug.msg(u'missing icon %s' % name, reason=u'warning')
		return icon
Beispiel #49
0
    def apply_script_changes(self, *deprecated, **_deprecated):
        """
		desc:
			Applies changes to the script, by re-parsing the item from string.
		"""

        debug.msg()
        old_script = self.to_string()
        new_script = self._script_widget.text()
        try:
            self.from_string(new_script)
        except osexception as e:
            self.experiment.notify(e.html())
            self.main_window.print_debug_window(e)
            self.from_string(old_script)
        self.edit_widget()
        self.main_window.set_unsaved(True)
    def run(self):

        """Run phase"""

        # self.set_item_onset() sets the time_[item name] variable. Optionally,
        # you can pass a timestamp, such as returned by canvas.show().

        # Set the pptrigger value
        if self.pptrigger_dummy == u'no':
            ## turn trigger on
            try:
                if os.name == 'nt':
                    self.set_item_onset(self.experiment.pptrigger.DlPortWritePortUchar(int(self.pptrigger_port,0), self.pptrigger_value))
                else:
                    self.set_item_onset(self.experiment.pptrigger.setData(self.pptrigger_value))
                debug.msg(u'Sending value %s to the parallel port on address: %s' % (self.pptrigger_value,self.pptrigger_port))

            except Exception as e:
                raise osexception(
                    u'Wrong port address, could not access the Parallel Port', exception=e)
            
            ## Executing duration and reset
            if self.pptrigger_duration_check == u'yes':
                # use keyboard as timeout, allowing for Escape presses to abort experiment

                if self.pptrigger_duration !=0:

                    self.kb.get_key(timeout=self.pptrigger_duration)
                    debug.msg(u'Waiting %s ms to reset' % (self.pptrigger_duration))
                
                try: 
                    if os.name == 'nt':
                        self.set_item_onset(self.experiment.pptrigger.DlPortWritePortUchar(int(self.pptrigger_port,0), 0))
                    else:
                        self.set_item_onset(self.experiment.pptrigger.setData(0))
                    debug.msg(u'Resetting the parallel port to zero')

                except Exception as e:
                    raise osexception(
                        u'Wrong port address, could not access the Parallel Port', exception=e)
                    
                    
        elif self.pptrigger_dummy == u'yes':
            debug.msg(u'Dummy mode enabled, NOT sending value %s to the parallel port on address: %s' % (self.pptrigger_value,self.experiment.pptrigger_port))
        else:
            debug.msg(u'Error with dummy mode!')
Beispiel #51
0
    def autosave(self):
        """
		desc:
			Autosave the experiment if there are unsaved changes.
		"""

        if self.main_window.unsaved_changes:
            path = os.path.join(
                self.autosave_folder,
                u'%s.osexp' % str(time.ctime()).replace(u':', u'_'))
            try:
                self.main_window.get_ready()
                self.experiment.save(path, overwrite=True, update_path=False)
                debug.msg(u"saving backup as %s" % path)
            except:
                pass
        self.start_autosave_timer()
Beispiel #52
0
    def __init__(self):
        """Constructor"""

        # The auto-widgets are stored in name -> (var, widget) dictionaries
        self.auto_line_edit = {}
        self.auto_combobox = {}
        self.auto_spinbox = {}
        self.auto_slider = {}
        self.auto_editor = {}
        self.auto_checkbox = {}

        self.init_edit_widget()
        self.init_script_widget()
        self.script_tab = None
        self.lock = False
        self.edit_mode = "edit"
        debug.msg("created %s" % self.name)
Beispiel #53
0
    def from_string(self, string):
        """
		desc:
			Reads the entire experiment from a string.

		arguments:
			string:	The definition string.
		"""

        self.var.clear(preserve=[u'experiment_path', u'experiment_file'])
        self.reset()
        self.comments = []
        debug.msg(u"building experiment")
        if string is None:
            return
        self.front_matter, string = self._syntax.parse_front_matter(string)
        if self.experiment.front_matter[u'API'].version[0] < 2:
            # Old experiment scripts were saved in ASCII, and require decoding
            # of U+XXXX unicode characters.
            string = self.syntax.from_ascii(string)
        s = iter(string.split(u'\n'))
        line = next(s, None)
        while line is not None:
            get_next = True
            try:
                l = self.syntax.split(line)
            except ValueError as e:
                raise osexception(
                    u'Failed to parse script. Maybe it contains '
                    u'illegal characters or unclosed quotes?',
                    exception=e)
            if l:
                self.parse_variable(line)
                # Parse definitions
                if l[0] == u"define":
                    if len(l) != 3:
                        raise osexception(u'Failed to parse definition',
                                          line=line)
                    item_type = l[1]
                    item_name = self.syntax.sanitize(l[2])
                    line, def_str = self.read_definition(s)
                    get_next = False
                    self.items.new(item_type, item_name, def_str)
            # Advance to next line
            if get_next:
                line = next(s, None)
Beispiel #54
0
	def restore_name(self, apply_name_change=True):

		"""
		Apply the name change and revert the edit control back to the static
		label

		Keywords arguments:
		apply_name_change -- indicates of the name change should be applied
							 (default=True)
		"""
		
		debug.msg(u"apply_name_change = %s" % apply_name_change)
		if apply_name_change:
			self.item.apply_name_change()			
		self.refresh()					
		self.label_name.show()
		self.edit_name.hide()
Beispiel #55
0
    def supported_events(self):
        """
		desc:
			Gives the events that are supported by the extension. This is done
			by introspecting which `event_[event name]` functions exist.

		returns:
			desc:	A list of supported events.
			type:	list
		"""

        events = []
        for event in dir(self):
            if event.startswith(u'event_'):
                events.append(event[6:])
                debug.msg(u'extension %s supports %s' % (self.name(), event))
        return events
Beispiel #56
0
    def refresh(self):
        """Update the controls of the general tab"""

        debug.msg()

        # Lock the general tab to prevent a recursive loop
        self.lock = True

        # Set the header containing the titel etc
        self.set_header_label()

        # Select the backend
        backend = openexp.backend_info.match(self.main_window.experiment)
        if backend == u"custom":
            self.ui.combobox_backend.setDisabled(True)
        else:
            self.ui.combobox_backend.setDisabled(False)
            desc = openexp.backend_info.backend_list[backend][u"description"]
            i = self.ui.combobox_backend.findText(self.backend_format \
             % (backend, desc))
            self.ui.combobox_backend.setCurrentIndex(i)

        # Set the resolution
        try:
            self.ui.spinbox_width.setValue(int( \
             self.main_window.experiment.width))
            self.ui.spinbox_height.setValue(int( \
             self.main_window.experiment.height))
        except:
            self.main_window.experiment.notify( \
             _(u"Failed to parse the resolution. Expecting positive numeric values."))

        # Set the colors
        self.ui.edit_foreground.setText(self.main_window.experiment.unistr( \
         self.main_window.experiment.foreground))
        self.ui.edit_background.setText(self.main_window.experiment.unistr( \
         self.main_window.experiment.background))

        # Set the font
        self.ui.widget_font.initialize(self.main_window.experiment)
        # Set variable transparency
        self.ui.checkbox_transparent_variables.setChecked( \
         self.main_window.experiment.get(u'transparent_variables') == u'yes')
        # Release the general tab
        self.lock = False
Beispiel #57
0
    def wizard(self):
        """Present the variable wizard dialog"""

        icons = {}
        icons["cut"] = self.experiment.icon("cut")
        icons["copy"] = self.experiment.icon("copy")
        icons["paste"] = self.experiment.icon("paste")
        icons["clear"] = self.experiment.icon("clear")

        # Set up the wizard dialog
        a = QtGui.QDialog(self.experiment.main_window.ui.centralwidget)
        a.ui = loop_wizard_dialog_ui.Ui_Dialog()
        a.ui.setupUi(a)
        self.experiment.main_window.theme.apply_theme(a)
        a.ui.table_example.build_context_menu(icons)
        a.ui.table_wizard.build_context_menu(icons)
        a.ui.table_example.hide()
        a.ui.table_wizard.setRowCount(255)
        a.ui.table_wizard.setColumnCount(255)

        if a.exec_() == QtGui.QDialog.Accepted:
            debug.msg("filling loop table")
            # First read the table into a dictionary of variables
            var_dict = {}
            for col in range(a.ui.table_wizard.columnCount()):
                var = None
                for row in range(a.ui.table_wizard.rowCount()):
                    item = a.ui.table_wizard.item(row, col)
                    if item == None:
                        break
                    s = item.text()
                    if row == 0:
                        var = self.experiment.sanitize(s, True)
                        var_dict[var] = []
                    elif var != None:
                        var_dict[var].append(self.experiment.usanitize(s))
            # Then fill the loop table
            self.i = 0
            self.matrix = {}
            self.wizard_process(var_dict)
            self.set_cycle_count(len(self.matrix))
            self.lock = True
            self.loop_widget.ui.spin_cycles.setValue(self.cycle_count())
            self.lock = False
            self.refresh_loop_table()
Beispiel #58
0
	def apply_desc(self):

		"""
		desc:
			Applies the description change and revert the edit back to the
			label.
		"""

		if self.label_desc.isVisible():
			return
		debug.msg()
		description = unicode(self.edit_desc.text())
		description = self.item.sanitize(description)
		self.item.set(u'description', description)
		self.label_desc.setText(description)
		self.label_desc.show()
		self.edit_desc.hide()
		self.item.apply_edit_changes()
Beispiel #59
0
    def initialize(self, experiment, color=None):
        """
		Initializes the widget.
		
		Arguments:
		experiment	--	The experiment object.
		
		Keyword arguments:
		color		--	A color to start with or None for experiment foreground
						default. (default=None)
		"""

        debug.msg(u'color = %s' % color)
        self.experiment = experiment
        if color == None:
            color = self.experiment.get(u'foreground', _eval=False)
        self.setText(color)
        self.button.setIcon(self.experiment.icon(u'colorpicker'))
    def execute(self):
        """See base_runner.execute()."""

        # Exceptions during the run phase are important and returned so that the
        # user is notified.
        e = None
        try:
            self.experiment.run()
        except Exception as e:
            if not isinstance(e, osexception):
                e = osexception(u'Unexpected error', e)
        # Exceptions during the end phase are less important and only printed
        # to the debug window.
        try:
            self.experiment.end()
        except Exception as _e:
            debug.msg(u'Exception during experiment.end(): %s' % _e)
        return e