. You will not be able to use parallel port connectivity. Error: %s" % e)
debug.msg("preloading 'pyglet'")
try:
import pyglet
except Exception as e:
debug.msg("failed to import 'pyglet' module . You will not be able to use PsychoPy. Error: %s" % e)
debug.msg("preloading modules required by questionnaire plug-ins")
try:
import htmllib
import htmlentitydefs
import HTMLParser
import sgmllib
import markupbase
except Exception as e:
debug.msg("failed to import modules required by questionnaire plug-ins")
debug.msg("preloading IPython")
try:
from IPython.frontend.qt.console.ipython_widget import IPythonWidget
from IPython.frontend.qt.kernelmanager import QtKernelManager
from IPython.utils.localinterfaces import LOCALHOST
except Exception as e:
debug.msg("failed to import IPython . You will not be able to use the IPython console. Error: %s" % e)
debug.msg("preloading OSX dependencies")
try:
from libqtopensesame.widgets import pool_widget, statusbar, tree_overview, toolbar_items, variable_inspector, good_looking_table
from libqtopensesame.items import exceptions, experiment, feedback, generic_response, inline_script, item, keyboard_response, logger, loop, misc, mouse_response, plugins, sampler, sequence, sketchpad, synth
except Exception as e:
debug.msg('Failed to load libqtopensesame.items modules')
try:
import pygame._view
except Exception as e:
debug.msg('Failed to load pygame._view')
opensesame-0.27.4/libqtopensesame/misc/dummy.py 0000664 0001750 0001750 00000001343 12173713501 024047 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
class qtplugin(object):
pass
class qtautoplugin(object):
pass opensesame-0.27.4/libqtopensesame/misc/__init__.py 0000664 0001750 0001750 00000002321 12214350637 024453 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
import sys
if '--catch-translatables' in sys.argv:
# Automatically catches all strings that require translation
from libopensesame import misc
import os.path
path = misc.resource(os.path.join(u'ts', u'translatables.txt'))
def _(s):
l = open(path).read().split(u'\n')
if s not in l:
f = open(path, u'a')
f.write(s + u'\n')
print u'New translatable: '+s
f.close()
return s
else:
# A simple wrapper arround the translate function
from PyQt4.QtCore import QCoreApplication
_ = lambda s: unicode(QCoreApplication.translate(u'script', s))
opensesame-0.27.4/libqtopensesame/misc/config.py 0000664 0001750 0001750 00000016075 12173713501 024171 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
USAGE
=====
This module is used to maintain configuration settings. There is a old and a new
style API. The new one is obviously preferred for new code.
OLD STYLE
=========
>>> from libqtopensesame.misc import config
>>> config.set_config('my_setting', 'my_value')
>>> print config.get_config('my_setting')
NEW STYLE
=========
>>> from libqtopensesame.misc.config import cfg
>>> cfg.my_setting = 'my_value' # set
>>> print cfg.my_setting # get
"""
from PyQt4 import QtCore
import libopensesame.misc
from libopensesame import debug, exceptions
import platform
import sip
if sip.getapi(u'QString') == 2:
QtCore.QStringList = list
class config(object):
config = {
u"cfg_ver" : 0,
u"_initial_window_geometry" : QtCore.QByteArray(),
u"_initial_window_state" : QtCore.QByteArray(),
u"auto_update_check" : True,
u"auto_response" : False,
u"autosave_interval" : 10 * 60 * 1000,
u"autosave_max_age" : 7,
u"default_logfile_folder" : libopensesame.misc.home_folder(),
u"default_pool_folder" : libopensesame.misc.home_folder(),
u"disabled_plugins" : "",
u"file_dialog_path" : "",
u"immediate_rename" : False,
u"locale" : u"default",
u"loop_wizard" : QtCore.QStringList(),
u"onetabmode" : False,
u"quick_run_logfile": u"quickrun.csv",
u"recent_files" : u"",
u"scintilla_line_numbers" : True,
u"scintilla_right_margin" : False,
u"scintilla_eol_visible" : False,
u"scintilla_whitespace_visible" : False,
u"scintilla_indentation_guides" : True,
u"scintilla_auto_indent" : True,
u"scintilla_folding" : True,
u"scintilla_brace_match" : True,
u"scintilla_syntax_highlighting" : True,
u"scintilla_custom_font" : False,
u"scintilla_font_family" : u"courier",
u"scintilla_font_size" : 10,
u"shortcut_itemtree" : u"Ctrl+1",
u"shortcut_tabwidget" : u"Ctrl+2",
u"shortcut_stdout" : u"Ctrl+3",
u"shortcut_pool" : u"Ctrl+4",
u"shortcut_variables" : u"Ctrl+5",
u"style" : u"",
u"theme" : u"default",
u"toolbar_size" : 32,
u"toolbar_text" : False,
u"opensesamerun" : False,
u"opensesamerun_exec" : u"",
u"pos" : QtCore.QPoint(200, 200),
u"size" : QtCore.QSize(1000, 600),
u"url_website" : u"http://www.cogsci.nl/opensesame",
u"url_facebook" : u"http://www.facebook.com/cognitivescience",
u"url_twitter" : u"http://www.twitter.com/cogscinl",
u"version_check_url" : \
u"http://files.cogsci.nl/software/opensesame/MOST_RECENT_VERSION.TXT"
}
# OS specific override settings
config_linux = {
u"theme" : u"gnome"
}
config_mac = {}
config_windows = {}
def __init__(self):
"""Constructor"""
# Determine the sip api that is used, because this depends on whether
# or not IPython is loaded
object.__setattr__(self, u'api', sip.getapi(u'QString'))
if self.api not in (1,2):
raise Exception(u'config: unknown api %s' % self.api)
# Apply OS specific override settings
if platform.system() == u"Windows":
for key, value in self.config_windows.iteritems():
self.config[key] = value
elif platform.system() == u"Darwin":
for key, value in self.config_mac.iteritems():
self.config[key] = value
elif platform.system() == u"Linux":
for key, value in self.config_linux.iteritems():
self.config[key] = value
def __getattr__(self, setting):
"""
A getter for settings, to allow for easy access
Argument:
setting -- the setting to get
"""
if setting not in self.config:
raise exceptions.runtime_error(u'The setting "%s" does not exist' \
% setting)
return self.config[setting]
def __setattr__(self, setting, value):
"""
A setter for settings, to allow for easy access
Argument:
setting -- the setting to set
value -- the value to set
"""
if setting not in self.config:
raise exceptions.runtime_error(u'The setting "%s" does not exist' \
% setting)
self.config[setting] = value
self.config[u'cfg_ver'] += 1
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 == 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)
def restore(self, qsettings):
"""
Restore settings from a QSettings
Arguments:
qsettings -- a QSettings instance
"""
for setting, default in self.config.items():
value = qsettings.value(setting, default)
# The older (default) api requires an explicit type conversion
if self.api == 1:
if type(default) == bool:
value = value.toBool()
elif type(default) == str:
try:
value = unicode(value.toString())
except:
value = default
elif type(default) == int:
value = value.toInt()[0]
elif type(default) == QtCore.QPoint:
value = value.toPoint()
elif type(default) == QtCore.QSize:
value = value.toSize()
elif type(default) == QtCore.QByteArray:
value = value.toByteArray()
elif type(default) == QtCore.QString:
value = value.toString()
elif type(default) == QtCore.QStringList:
value = value.toStringList()
elif type(default) == unicode:
value = unicode(value.toString())
# The newer api returns some things as strings, so we still have to
# do some type conversion
else:
if type(default) == bool:
if value == u'false':
value = False
else:
value = True
elif type(default) == int:
value = int(value)
self.__setattr__(setting, value)
def save(self, qsettings):
"""
Save settings to a QSettings
Arguments:
qsettings -- a QSettings instance
"""
for setting, value in self.config.items():
if setting != u"cfg_ver":
qsettings.setValue(setting, value)
# Old style API. See explanation above
def get_config(setting):
return cfg.__getattr__(setting)
def set_config(setting, value):
cfg.__setattr__(setting, value)
def restore_config(settings):
cfg.restore(settings)
def save_config(settings):
cfg.save(settings)
def parse_cmdline_args(args):
cfg.parse_cmdline_args(args)
# Create a singleton config instance
global cfg
cfg = config()
opensesame-0.27.4/libqtopensesame/misc/dispatch.py 0000664 0001750 0001750 00000012237 12173713501 024517 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
DISPATCH LOGIC
==============
The following elements can be affected by a change in an item
+ Item tree
+ Affected by name changes
+ Affected by sequence and loop changes
- Loop items
+ Affected by name changes (only if parent)
- Sequence items
+ Affected by name changes (only if parent)
To handle this, we have the following events
+ name_change
Refresh item tree
Refresh loops
Refresh sequences
+ script_change
"""
from PyQt4 import QtCore
from libqtopensesame.misc import _
from libqtopensesame.items import experiment
import libopensesame.exceptions
import sip
import traceback
class dispatch(QtCore.QObject):
"""
The dispatch is informed of changes and passes these on to the various
parts of the GUI.
"""
event_name_change = QtCore.pyqtSignal([str, str], name=u'nameChange')
event_regenerate = QtCore.pyqtSignal([str], name=u'regenerate')
event_script_change = QtCore.pyqtSignal([str], [sip.voidptr], \
name=u'scriptChange')
event_simple_change = QtCore.pyqtSignal([str], [sip.voidptr], \
name=u'simpleChange')
event_structure_change = QtCore.pyqtSignal([str], [sip.voidptr], \
name=u'structureChange')
def __init__(self, main_window):
"""
Constructor.
Arguments:
main_window -- The main window.
"""
QtCore.QObject.__init__(self)
self.main_window = main_window
self.event_name_change.connect(self.name_change)
self.event_regenerate.connect(self.regenerate)
self.event_script_change[str].connect(self.script_change)
self.event_script_change[sip.voidptr].connect(self.script_change)
self.event_simple_change[str].connect(self.simple_change)
self.event_simple_change[sip.voidptr].connect(self.simple_change)
self.event_structure_change[str].connect(self.structure_change)
self.event_structure_change[sip.voidptr].connect(self.structure_change)
def regenerate(self, script):
"""
Handles a full regeneration of the experiment.
Arguments:
script -- A definition Unicode string / QString.
"""
self.main_window.set_busy(True)
script = self.main_window.experiment.unistr(script)
try:
# Generate the new experiment
tmp = experiment.experiment(self.main_window, \
self.main_window.experiment.title, script, \
self.main_window.experiment.pool_folder)
except Exception as error:
# If something is wrong with the script, notify the user and print
# a traceback to the debug window
self.main_window.experiment.notify( \
_(u'Failed to parse script (see traceback in debug window): %s') \
% error)
self.main_window.print_debug_window(error)
return
# Apply the new experiment
self.main_window.experiment = tmp
self.main_window.experiment.build_item_tree()
self.main_window.ui.tabwidget.close_all()
self.main_window.ui.tabwidget.open_general_script()
self.main_window.set_busy(False)
self.main_window.set_unsaved()
def script_change(self, name=None):
"""
Handles a change to an items script.
Arguments:
name -- The name of an item. (default=None)
"""
self.main_window.experiment.build_item_tree()
self.simple_change(name)
def simple_change(self, name=None):
"""
Handles simple changes to an item.
Arguments:
name -- The name of an item.
"""
self.main_window.refresh_variable_inspector()
self.main_window.set_unsaved()
def structure_change(self, name=None):
"""
Handles changes to the structure of the experiment.
Arguments:
name -- The name of the item that caused the change.
(default=None)
"""
self.main_window.experiment.build_item_tree()
self.simple_change(name)
def name_change(self, from_name, to_name):
"""
Handles the name change of an item.
Arguments:
from_name -- The previous name.
to_name -- The new name.
"""
from_name = unicode(from_name)
to_name = unicode(to_name)
self.main_window.set_busy(True)
# Rename the item in the experiment item list
item = self.main_window.experiment.items[from_name]
del self.main_window.experiment.items[from_name]
self.main_window.experiment.items[to_name] = item
# Give all items the chance to process the name change
for item in self.main_window.experiment.items:
self.main_window.experiment.items[item].rename(from_name, to_name)
# Rebuild the item tree
self.main_window.experiment.build_item_tree()
# Rename the item tab
i = self.main_window.ui.tabwidget.get_item(to_name)
if i != None:
self.main_window.ui.tabwidget.setTabText(i, to_name)
# Also process simple changes
self.simple_change(to_name)
self.main_window.set_busy(False)
opensesame-0.27.4/libqtopensesame/misc/template_info.py 0000664 0001750 0001750 00000002321 12143215416 025536 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
templates = [
('templates/default.opensesame', 'Default template'),
('templates/extended_template.opensesame', 'Extended template'),
('templates/android_template.opensesame', 'Runtime for Android template'),
('templates/eco_alt_template.opensesame.tar.gz',
'Stimulus set: an ecological alternative to Snodgrass & Vanderwart'),
('templates/gaped_template.opensesame.tar.gz',
'Stimulus set: the Geneva affective picture database (GAPED)'),
('templates/boss_template.opensesame.tar,gz',
'Stimulus set: the bank of standardized stimuli (BOSS)')
]
opensesame-0.27.4/libqtopensesame/widgets/ 0000775 0001750 0001750 00000000000 12214554461 023060 5 ustar sebastiaan sebastiaan 0000000 0000000 opensesame-0.27.4/libqtopensesame/widgets/item_context_menu.py 0000664 0001750 0001750 00000006165 12173713501 027164 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.misc import _
class item_context_menu(QtGui.QMenu):
"""Provides a basic context menu for an item"""
def __init__(self, title, parent, item, parent_item=None, index=None):
"""
Constructor
Arguments:
title -- menu title
parent -- parent widget
item -- the item to which this context menu belongs
Keyword arguments:
parent_item -- the parent of the item (default=None)
index -- the index of the item in the parent item (if applicable)
(default=None)
"""
QtGui.QMenu.__init__(self, title, parent)
self.item = item
self.parent_item = parent_item
self.index = index
# The menu text
self.open_text = _("Open %s") % item.name
self.edit_text = _("Edit script")
self.rename_text = _("Rename")
self.delete_text = _("Delete")
self.help_text = _("%s help") % item.item_type.capitalize()
self.addAction(item.experiment.icon(item.item_type), self.open_text)
self.addAction(item.experiment.icon("script"), self.edit_text)
self.addSeparator()
self.addAction(item.experiment.icon("rename"), self.rename_text)
if parent_item != None:
self.addAction(item.experiment.icon("delete"), self.delete_text)
self.addSeparator()
self.addAction(item.experiment.icon("help"), self.help_text)
def popup(self, pos):
"""
Show the menu and execute the chosen action
Arguments:
pos -- the position to popup
"""
action = self.exec_(pos)
if action == None:
return
action = unicode(action.text())
if action == self.open_text:
self.item.open_edit_tab()
elif action == self.edit_text:
self.item.open_script_tab()
elif action == self.rename_text:
self.rename()
elif action == self.help_text:
self.item.open_help_tab()
elif action == self.delete_text:
self.item.experiment.delete(self.item.name, self.parent_item, \
self.index)
def rename(self):
"""Rename an item"""
new_name, ok = QtGui.QInputDialog.getText(self, _(u'Rename'), \
_(u'Please enter a new name'), text=self.item.name)
new_name = self.item.experiment.sanitize(new_name, strict=True, \
allow_vars=False)
if ok:
# Do not allow names that are already in use, but do allow
# capitalization changes.
if new_name.lower() != self.item.name.lower():
valid = self.item.experiment.check_name(new_name)
if valid != True:
self.item.experiment.notify(valid)
return
# Accept
self.item.experiment.main_window.set_unsaved()
self.item.experiment.rename(self.item.name, new_name)
opensesame-0.27.4/libqtopensesame/widgets/pool_widget.py 0000664 0001750 0001750 00000024205 12061663322 025746 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from libopensesame import debug, misc
from libqtopensesame.ui import pool_widget_ui
from libqtopensesame.misc import _
from libqtopensesame.misc.config import cfg
from PyQt4 import QtCore, QtGui
import os
import platform
import os.path
import shutil
import subprocess
class pool_widget(QtGui.QWidget):
"""The file pool widget"""
def __init__(self, main_window, parent = None):
"""
Constructur
Arguments:
main_window -- the GUI main window
Keyword arguments:
parent -- a parent widget (default = None)
"""
# Known image and sound extensions
self.exts = {"image" : (".png", ".jpg", ".bmp", ".gif", ".jpeg"), \
"sound" : (".ogg", ".wav"), \
"text" : (".txt", ".csv", ".tsv"), \
"python" : (".py", ".pyc"), \
"video" : (".avi", ".mpg", ".wmv", ".mpeg", ".mov", ".ogv", \
".mp4", ".flv"), \
"pdf" : (".pdf"), \
}
self.main_window = main_window
self.max_len = 5
QtGui.QWidget.__init__(self, parent)
self.ui = pool_widget_ui.Ui_pool_widget()
self.ui.setupUi(self)
self.ui.button_pool_add.clicked.connect(self.select_and_add)
self.ui.button_refresh.clicked.connect(self.refresh)
self.ui.button_help_pool.clicked.connect(self.help)
self.ui.button_browse_pool.clicked.connect(self.browse)
self.ui.edit_pool_filter.textChanged.connect(self.refresh)
self.ui.combobox_view.currentIndexChanged.connect(self.set_view)
self.ui.list_pool.itemActivated.connect(self.activate_file)
self.main_window.theme.apply_theme(self)
self.ui.combobox_view.setItemIcon(0, self.main_window.theme.qicon( \
"view-list-details-symbolic"))
self.ui.combobox_view.setItemIcon(1, self.main_window.theme.qicon( \
"view-list-icons-symbolic"))
def help(self):
"""Open the help tab"""
self.main_window.open_help_tab("Help: File pool", "pool")
def set_view(self):
"""Set the viewmode (list/ icons) based on the gui control"""
if self.ui.combobox_view.currentIndex() == 0:
self.ui.list_pool.setViewMode(QtGui.QListView.ListMode)
else:
self.ui.list_pool.setViewMode(QtGui.QListView.IconMode)
def browse(self):
"""Open the pool folder in the file manager in an OS specific way"""
misc.open_url(self.main_window.experiment.pool_folder)
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)
def select_and_add(self, dummy = None):
"""
Add one or more files to the pool
Keyword arguments:
dummy -- a dummy argument passed py the signal handler (default=None)
"""
path_list = QtGui.QFileDialog.getOpenFileNames( \
self.main_window.ui.centralwidget, _("Add files to pool"), \
directory=cfg.default_pool_folder)
if len(path_list) == 0:
return
cfg.default_pool_folder = os.path.dirname(unicode(path_list[0]))
self.add(path_list)
def select(self, fname):
"""
Select a specific file in the file pool
Arguments:
fname -- the file to be selected
"""
for i in range(self.ui.list_pool.count()):
item = self.ui.list_pool.item(i)
if unicode(item.text()) == fname:
self.ui.list_pool.setCurrentItem(item)
def file_type(self, fname):
"""
Determine the type of a file based on the extension
Arguments:
fname -- the file under investigation
Returns:
A string with the filetype or "unknown"
"""
ext = os.path.splitext(fname)[1].lower()
for file_type in self.exts:
if ext in self.exts[file_type]:
return file_type
return "unknown"
def refresh(self):
"""Refresh the contents of the pool widget"""
filt = unicode(self.ui.edit_pool_filter.text()).lower()
self.ui.list_pool.clear()
# This function can be called after the pool has been cleaned
# up. This should not lead to a warning.
if not os.path.exists(self.main_window.experiment.pool_folder):
return
for fname in os.listdir(unicode( \
self.main_window.experiment.pool_folder)):
debug.msg(fname)
if filt in fname.lower():
icon = self.main_window.experiment.icon(self.file_type(fname))
item = QtGui.QListWidgetItem(icon, fname)
item.icon = icon
item.path = os.path.join( \
self.main_window.experiment.pool_folder, fname)
self.ui.list_pool.addItem(item)
def open_file(self, path):
"""
Open a file in a platform specific way
Arguments:
path -- the full path to the file to be opened
"""
misc.open_url(path)
def activate_file(self, item):
"""
Is called when a file is double-clicked or
otherwise activated and opens the file.
Arguments:
item -- a listWidgetItem
"""
self.open_file(item.path)
def contextMenuEvent(self, event):
"""
Presents a context menu
Arguments:
event -- a mouseClickEvent
"""
item = self.ui.list_pool.itemAt(self.ui.list_pool.mapFromGlobal( \
event.globalPos()))
if item == None:
return
menu = QtGui.QMenu()
menu.addAction(item.icon, _("Open"))
menu.addSeparator()
menu.addAction(self.main_window.experiment.icon("delete"), \
_("Remove from pool"))
menu.addAction(self.main_window.experiment.icon("rename"), _("Rename"))
menu.triggered.connect(self.context_action)
self.context_target = unicode(item.text())
menu.exec_(event.globalPos())
def context_action(self, action):
"""
Perform a conext menu action
Arguments:
action -- the action to be performed
"""
a = unicode(action.text())
f = os.path.join(self.main_window.experiment.pool_folder, \
self.context_target)
if a == _("Open"):
self.open_file(f)
elif a == _("Remove from pool"):
# Prepare the confirmation dialog, which contains a limited nr of
# filenames
l = []
suffix = ''
for item in self.ui.list_pool.selectedItems()[:self.max_len]:
l.append(unicode(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)
# Ask for confirmation
resp = QtGui.QMessageBox.question(self, _("Remove"), \
_("Are you sure you want to remove the following files from the file pool? This operation will only affect the OpenSesame file pool, not the original files on your disk.
- %s
%s
") \
% ("
- ".join(l), suffix), QtGui.QMessageBox.Yes, \
QtGui.QMessageBox.No)
if resp == QtGui.QMessageBox.No:
return
# Create a list of files to be removed
dL = []
for item in self.ui.list_pool.selectedItems():
dL.append(unicode(item.text()))
# Remove the files
try:
for f in dL:
os.remove(os.path.join( \
self.main_window.experiment.pool_folder, f))
debug.msg("removed '%s'" % self.context_target)
except:
debug.msg("failed to remove '%s'" % self.context_target)
else:
# Rename the file
new_name, ok = QtGui.QInputDialog.getText(self, _("Rename"), \
_("Please enter a new name for '%s'") \
% self.context_target, text = self.context_target)
if ok:
new_name = unicode(new_name)
if os.path.exists(os.path.join( \
self.main_window.experiment.pool_folder, new_name)):
self.main_window.experiment.notify( \
_("There already is a file named '%s' in the file pool") \
% new_name)
return
try:
os.rename(f, os.path.join( \
self.main_window.experiment.pool_folder, new_name))
debug.msg("renamed '%s' to '%s'" % (self.context_target, \
new_name))
except:
debug.msg("failed to rename '%s' to '%s'" % \
(self.context_target, new_name))
self.main_window.set_unsaved()
self.refresh()
def dragEnterEvent(self, event):
"""
Accept an incoming drag that precedes a drop
Arguments:
event -- a drag event
"""
event.acceptProposedAction()
def dropEvent(self, event):
"""
Accept an incoming drop
Arguments:
event -- a drop event
"""
files = []
for url in event.mimeData().urls():
files.append(url.toLocalFile())
self.add(files)
event.acceptProposedAction()
def select_from_pool(main_window):
"""
A static function that presents the select from pool dialog
Arguments:
main_window -- the GUI main window
"""
d = QtGui.QDialog(main_window.ui.centralwidget)
widget = pool_widget(main_window)
widget.refresh()
bbox = QtGui.QDialogButtonBox(d)
bbox.addButton(_("Cancel"), QtGui.QDialogButtonBox.RejectRole)
bbox.addButton(_("Select"), QtGui.QDialogButtonBox.AcceptRole)
bbox.accepted.connect(d.accept)
bbox.rejected.connect(d.reject)
vbox = QtGui.QVBoxLayout()
vbox.addWidget(widget)
vbox.addWidget(bbox)
d.setLayout(vbox)
d.setWindowTitle(_("Select file from pool"))
res = d.exec_()
main_window.refresh_pool()
if res == QtGui.QDialog.Rejected:
return ""
selected = widget.ui.list_pool.currentItem()
if selected == None:
return ""
return unicode(selected.text())
opensesame-0.27.4/libqtopensesame/widgets/tab_widget.py 0000664 0001750 0001750 00000016770 12173713501 025552 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from libopensesame import debug
from libqtopensesame.misc import config, _
from PyQt4 import QtGui, QtCore
class tab_widget(QtGui.QTabWidget):
"""A custom tab widget with some extra functionality"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- the parent QWidget
"""
QtGui.QTabWidget.__init__(self, parent)
try:
self.tabCloseRequested.connect(self.removeTab)
except:
# Catch what appears to be a bug in earlier versions of PyQt4.
self.tabCloseRequested.connect(self._removeTab)
self.currentChanged.connect(self.index_changed)
self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding, \
QtGui.QSizePolicy.MinimumExpanding)
def _removeTab(self, i):
"""
This is simply a wrapper around QTabWidget.removeTab(). For some reason,
connecting this function to tabCloseRequested causes an exception on
older versions of PyQt4. This functions is a workaround.
Arguments:
i -- The index of the tab to close.
"""
self.removeTab(i)
def add(self, widget, icon, name):
"""
Open a tab and switch to it
Arguments:
widget -- a QWidget for the tab
icon -- the name of an icon or a QIcon
name -- a name for the tab
"""
self.setCurrentIndex(self.addTab(widget, \
self.main_window.experiment.icon(icon), _(name)))
def close_all(self):
"""Close all tabs"""
while self.count() > 0:
self.removeTab(0)
def close_current(self):
"""Close the current tab"""
self.removeTab(self.currentIndex())
def close_other(self):
"""Close all tabs except for the currently opened one"""
while self.count() > 0 and \
self.currentIndex() != 0:
self.removeTab(0)
while self.count() > 1:
self.removeTab(1)
def get_index(self, tab_name):
"""
Return the index of a specific tab
Arguments:
tab_name -- the tab_name of the widget
Returns:
The index of the tab or None if the tab wasn't found
"""
for i in range(self.count()):
w = self.widget(i)
if (hasattr(w, "tab_name") and w.tab_name == tab_name) or \
(hasattr(w, tab_name)):
return i
return None
def get_item(self, item):
"""
Return the index of a specific item tab
Arguments:
item -- the name of the item
Returns:
The index of the tab or None if the tab wasn't found
"""
for i in range(self.count()):
w = self.widget(i)
if (hasattr(w, "__edit_item__") and w.__edit_item__ == item):
return i
return None
def get_widget(self, tab_name):
"""
Return a specific tab
Arguments:
tab_name -- the tab_name of the widget
Returns:
A QWidget or None if the tab wasn't found
"""
i = self.get_index(tab_name)
if i == None:
return None
return self.widget(i)
def open_about(self):
"""Open the about help tab"""
self.open_browser(u'http://osdoc.cogsci.nl/about/')
def open_browser(self, url):
"""
Open a browser tab to browse local or remote HTML files
Argument:
url -- a url
"""
from libqtopensesame.widgets import webbrowser
browser = webbrowser.webbrowser(self.main_window)
browser.load(url)
self.add(browser, "web-browser", 'Help')
def open_help(self, title, item):
"""
Open a help tab for the specified item. Looks for a file
called [item].html in the resources folder.
Arguments:
title -- the tab title
item -- the item for which help should be displayed
"""
self.open_browser(self.main_window.experiment.help("%s.html" % item))
def open_backend_settings(self):
"""Opens the backend settings"""
if self.switch('__backend_settings__'):
return
from libqtopensesame.widgets.backend_settings import backend_settings
self.add(backend_settings(self.main_window), 'backend', \
'Back-end settings')
def open_forum(self):
"""Open osdoc.cogsci.nl"""
self.open_browser('http://forum.cogsci.nl')
def open_general(self):
"""Opens the general tab"""
if self.switch('__general_properties__'):
return
from libqtopensesame.widgets.general_properties import general_properties
w = general_properties(self.main_window)
self.add(w, 'experiment', 'General properties')
def open_general_help(self):
"""Open the general help tab"""
self.open_help("Help: General", "general")
def open_general_script(self):
"""Opens the general script editor"""
if self.switch('__general_script__'):
return
from libqtopensesame.widgets.general_script_editor import \
general_script_editor
self.add(general_script_editor(self.main_window), 'terminal', \
'General script editor')
def open_osdoc(self):
"""Open osdoc.cogsci.nl"""
self.open_browser('http://osdoc.cogsci.nl')
def open_stdout_help(self):
"""Open the debug window help tab"""
self.open_help("Help: Debug window", "stdout")
def open_unused(self):
"""Opens the unused tab"""
if self.switch('__general__'):
return
from libqtopensesame.widgets.unused_widget import unused_widget
w = unused_widget(self.main_window)
self.add(w, 'unused', 'Unused items')
def open_variables_help(self):
"""Open the variable inspector help tab"""
self.open_help("Help: Variable inspector", "variables")
def open_preferences(self):
"""Open the preferences tab"""
from libqtopensesame.widgets import preferences_widget
if not self.switch("__preferences__"):
self.add(preferences_widget.preferences_widget(self.main_window), \
"options", "Preferences")
def open_start_new(self, start=False):
"""
Opens the start new tab
Keyword arguments:
start -- indicates whether the widget is opened because OpenSesame has
started (True) or because the new button has been clicked
(False) (default=True)
"""
if start:
if self.switch('__start_wizard__'):
return
else:
if self.switch('__new_wizard__'):
return
from libqtopensesame.widgets.start_new_widget import start_new_widget
w = start_new_widget(self.main_window, start=start)
self.add(w, 'os-experiment', 'Get started')
def switch(self, tab_name):
"""
Switch to a specific tab
Returns:
True if the tab exists, False otherwise
"""
i = self.get_index(tab_name)
if i == None:
return False
self.setCurrentIndex(i)
return True
def toggle_onetabmode(self):
"""Toggles onetabmode"""
config.set_config("onetabmode", \
self.main_window.ui.action_onetabmode.isChecked())
if config.get_config("onetabmode"):
self.close_other()
self.setTabsClosable(not config.get_config("onetabmode"))
self.main_window.ui.action_close_other_tabs.setEnabled(not \
config.get_config("onetabmode"))
def index_changed(self, index):
"""
Monitors tab index changes, closing other tabs if onetabmode is enabled
Arguments:
index -- the index of the new tab
"""
if config.get_config("onetabmode"):
self.close_other()
w = self.currentWidget()
if hasattr(w, 'on_activate'):
w.on_activate()
opensesame-0.27.4/libqtopensesame/widgets/statusbar.py 0000664 0001750 0001750 00000004146 12061663322 025444 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from PyQt4 import QtCore, QtGui
from libqtopensesame.misc import _
class statusbar(QtGui.QStatusBar):
"""A fancy statusbar with icons"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- the parent QWidget
"""
QtGui.QStatusBar.__init__(self, parent)
self.initialized = False
def init(self):
"""Initialize the statusbar"""
self.ready_icon = self.parent().experiment.label_image("status_ready")
self.busy_icon = self.parent().experiment.label_image("status_busy")
self.message = QtGui.QLabel()
self.addWidget(self.ready_icon)
self.addWidget(self.busy_icon)
self.addWidget(self.message)
self.initialized = True
def set_status(self, msg, timeout=5000, status="ready"):
"""
Set a statusbar message
Arguments:
msg -- the message
Keywords arguments:
timeout -- the timeout of the message (default=5000)
status -- the message status (ready/busy) (default='ready')
"""
if not self.initialized:
self.init()
if status == "ready":
self.ready_icon.show()
self.busy_icon.hide()
else:
self.ready_icon.hide()
self.busy_icon.show()
self.message.setText("%s" % msg)
if timeout != None:
QtCore.QTimer.singleShot(timeout, self.clear_status)
def clear_status(self):
"""Clear the statusbar to a default ready message"""
self.set_status(_("Ready"), timeout=None)
opensesame-0.27.4/libqtopensesame/widgets/color_edit.py 0000664 0001750 0001750 00000005140 12173713501 025551 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libopensesame import debug
class color_edit(QtGui.QWidget):
"""A colorpicker QWidget with a QLineEdit and a QPushButton."""
def __init__(self, parent=None):
"""
Constructor.
Arguments:
experiment -- The experiment object.
Keywords arguments:
parent -- The parent QWidget. (default=None)
"""
QtGui.QWidget.__init__(self, parent)
self.edit = QtGui.QLineEdit()
self.edit.editingFinished.connect(self.apply)
self.editingFinished = self.edit.editingFinished
self.button = QtGui.QPushButton()
self.button.setIconSize(QtCore.QSize(16,16))
self.button.clicked.connect(self.colorpicker)
layout = QtGui.QHBoxLayout()
layout.setContentsMargins(0,0,0,0)
layout.addWidget(self.edit)
layout.addWidget(self.button)
self.setLayout(layout)
def colorpicker(self):
"""Picks a color with the colorpicker dialog."""
color = self.experiment.colorpicker(self.experiment.sanitize( \
self.text()))
if color == None:
return
self.setText(color)
self.apply()
def text(self):
"""
Returns the text (emulate QLineEdit behavior).
Returns:
A QString.
"""
return self.edit.text()
def setText(self, s):
"""
Sets the text (emulate QLineEdit behavior).
Arguments:
s -- The text.
"""
self.edit.setText(s)
def apply(self):
"""Emit a 'set_color' signal to indicate that a color has been picker"""
self.emit(QtCore.SIGNAL(u'set_color'))
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'))
opensesame-0.27.4/libqtopensesame/widgets/pyterm_ipython.py 0000664 0001750 0001750 00000004303 12214350640 026515 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
import sys
from IPython.frontend.qt.console.ipython_widget import IPythonWidget
from IPython.frontend.qt.kernelmanager import QtKernelManager
from IPython.utils.localinterfaces import LOCALHOST
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4 import QtGui
class output_buffer:
"""Used to capture the standard output and reroute it to the debug window"""
def __init__(self, console):
"""
Constructor
Keyword arguments:
console -- a console widget
"""
self.console = console
def write(self, s):
"""
Write a string
Arguments:
s -- a string
"""
self.console.console._append_plain_text(s)
def flush(self):
"""Dummy flush function for compatibility."""
pass
class console(QWidget):
"""A QWidget that serves as a debug window"""
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.main_window = parent
self.kernel_manager = QtKernelManager()
self.kernel_manager.start_kernel()
self.kernel_manager.start_channels()
self.console = IPythonWidget(local_kernel=LOCALHOST)
self.console.kernel_manager = self.kernel_manager
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setContentsMargins(0,0,0,0)
self.setLayout(self.verticalLayout)
self.verticalLayout.addWidget(self.console)
def setReadOnly(self, state):
"""
Dummy function
Arguments:
state -- dummy argument
"""
pass
def clear(self):
"""Clears the console"""
self.console.reset()
def show_prompt(self):
"""Shows a new prompt"""
self.console._show_interpreter_prompt()
opensesame-0.27.4/libqtopensesame/widgets/variable_inspector.py 0000664 0001750 0001750 00000004607 12061663322 027311 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from libopensesame import debug
from PyQt4 import QtCore, QtGui
class sortable(QtGui.QTableWidgetItem):
"""A sortable tablewidget"""
def __init__(self, text, sort_key):
"""
Constructor
Arguments:
text -- the cell text
sort_key -- the key to use for sorting
"""
QtGui.QTableWidgetItem.__init__(self, text, \
QtGui.QTableWidgetItem.UserType)
self.sort_key = sort_key
def __lt__(self, other):
"""
Sort operator (less than)
Arguments:
other -- the other sortable
"""
return self.sort_key < other.sort_key
class variable_inspector(QtGui.QTableWidget):
"""The table for the variable inspector"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- the parent QWidget
"""
QtGui.QTableWidget.__init__(self, parent)
self.unsorted = True
def refresh(self):
"""Updates and restores the variable inspector"""
debug.msg()
if self.unsorted:
self.sortItems(0, QtCore.Qt.AscendingOrder)
self.unsorted = False
scrollpos = self.verticalScrollBar().sliderPosition()
col = self.currentColumn()
row = self.currentRow()
filt = unicode(self.main_window.ui.edit_variable_filter.text())
self.setSortingEnabled(False)
i = 0
for var, val, item in self.main_window.experiment.var_list(filt):
self.insertRow(i)
val = self.main_window.experiment.unistr(val)
self.setItem(i, 0, sortable(var, u'%s_%s_%s' % (var,val,item)))
self.setItem(i, 1, sortable(val, u'%s_%s_%s' % (val,var,item)))
self.setItem(i, 2, sortable(item, u'%s_%s_%s' % (item,var,val)))
i += 1
self.setRowCount(i)
self.setSortingEnabled(True)
self.setCurrentCell(row, col)
self.verticalScrollBar().setSliderPosition(scrollpos)
opensesame-0.27.4/libqtopensesame/widgets/inline_editor.py 0000664 0001750 0001750 00000026227 12173713501 026263 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
import os
from PyQt4 import QtGui, QtCore
from PyQt4.Qsci import QsciScintilla, QsciScintillaBase, QsciLexerPython, \
QSCINTILLA_VERSION
from libqtopensesame.misc import config, _
from libqtopensesame.dialogs.replace_dialog import replace_dialog
from libopensesame import debug
class python_lexer(QsciLexerPython):
"""Handles Python syntax highlighting"""
def __init__(self, font):
"""
Constructor
Arguments:
font -- a QFont
"""
QsciLexerPython.__init__(self)
self.setDefaultFont(font)
self.setIndentationWarning(self.Inconsistent)
class scintilla(QsciScintilla):
"""The text editor"""
focusLost = QtCore.pyqtSignal()
def __init__(self, parent=None, syntax=None):
"""
Constructor
Keywords arguments:
parent -- parent QWidget
syntax -- the syntax highlighter 'python', 'opensesame' or None
(default=None)
"""
self._parent = parent
QsciScintilla.__init__(self, parent)
self.syntax = syntax
self.textChanged.connect(self._parent.setModified)
self.refresh_layout = True
self.cfg_ver = config.get_config("cfg_ver")
self.setUtf8(True)
self.setEolMode(self.EolUnix)
def paintEvent(self, e):
"""Optionally refresh the layout before a paint event"""
if self.refresh_layout:
self.set_layout()
self.refresh_layout = False
QsciScintilla.paintEvent(self, e)
def set_layout(self):
"""Initialize the editor layout"""
if config.get_config("scintilla_custom_font"):
font_family = config.get_config("scintilla_font_family")
elif os.name == "posix":
font_family = "mono"
else:
font_family = "courier"
font = QtGui.QFont(font_family)
font.setFixedPitch(True)
if config.get_config("scintilla_custom_font"):
font.setPointSize(config.get_config("scintilla_font_size"))
fm = QtGui.QFontMetrics(font)
self.setFont(font)
self.setMarginsFont(font)
self.setTabWidth(4)
# Set line numbers
self.setMarginWidth(0, fm.width( "0000" ))
self.setMarginLineNumbers(0, config.get_config( \
"scintilla_line_numbers"))
# Set the right margin
self.setEdgeColumn(80)
if config.get_config("scintilla_right_margin"):
self.setEdgeMode(QsciScintilla.EdgeLine)
else:
self.setEdgeMode(QsciScintilla.EdgeNone)
# Set EOL visibility
self.setEolVisibility(config.get_config("scintilla_eol_visible"))
# Set whitespace visibility
if config.get_config("scintilla_whitespace_visible"):
self.setWhitespaceVisibility(QsciScintilla.WsVisible)
else:
self.setWhitespaceVisibility(QsciScintilla.WsInvisible)
# Set indentation guides
self.setIndentationGuides(config.get_config( \
"scintilla_indentation_guides"))
# Set auto indent
self.setAutoIndent(config.get_config("scintilla_auto_indent"))
# Set folding
if config.get_config("scintilla_folding"):
self.setFolding(QsciScintilla.BoxedTreeFoldStyle)
else:
self.setFolding(QsciScintilla.NoFoldStyle)
# Set brace matching
if config.get_config("scintilla_brace_match"):
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
else:
self.setBraceMatching(QsciScintilla.NoBraceMatch)
# Set syntax highlighting.
if config.get_config("scintilla_syntax_highlighting") and \
(self.syntax == "python" or self.syntax == "opensesame"):
self.setLexer(python_lexer(font))
for i in range(16): # There are properties that need to be forced
# In Ubuntu 13.04, forcing the font actually causes the font
# to be reset. This is an ugly hack to prevent that from
# happening, assuming that this regression is due to the version
# of Qscintilla.
if QSCINTILLA_VERSION < 132865:
self.SendScintilla(QsciScintilla.SCI_STYLESETFONT, i, \
font.family())
self.SendScintilla(QsciScintilla.SCI_STYLESETSIZE, i, \
font.pointSize())
else:
self.setLexer(None)
self.SendScintilla(QsciScintilla.SCI_CLEARDOCUMENTSTYLE)
def toPlainText(self):
"""
Convenience function for compatibility with QPlainTextEdit
Returns:
A unicode string with the editor contents
"""
return unicode(self.text())
def setPlainText(self, s, set_modified=False):
"""
(For compatibility with QPlainTextEdit)
Arguments:
s -- the new contents of the editor
Keyword arguments:
set_modified -- indicates whether the modified flag should be set
(default=False)
"""
if not set_modified:
_m = self.isModified()
self.textChanged.disconnect()
self.setText(self._parent.experiment.unistr(s))
if not set_modified:
self.textChanged.connect(self._parent.setModified)
self._parent.setModified(_m)
else:
self._parent.setModified(True)
def focusOutEvent(self, e):
"""Send a focusLost signal if we lose focus"""
self.emit(QtCore.SIGNAL("focusLost"))
self.focusLost.emit()
QsciScintilla.focusOutEvent(self, e)
def focusInEvent(self, e):
"""Refresh the layout on a focus in event"""
# Only update the layout if the config is outdated
if self.cfg_ver != config.get_config("cfg_ver"):
self.set_layout()
self.cfg_ver = config.get_config("cfg_ver")
QsciScintilla.focusInEvent(self, e)
def keyPressEvent(self, e):
"""
Captures keypresses to implement apply (Alt+A
Arguments:
e -- a keypress even
"""
# Process the Alt + A shortcut to apply changes
if e.key() == QtCore.Qt.Key_A and \
e.modifiers() == QtCore.Qt.AltModifier:
self._parent.apply.clicked.emit(True)
return
if e.key() == QtCore.Qt.Key_F and \
e.modifiers() == QtCore.Qt.ControlModifier:
self._parent.perform_replace()
return
QsciScintilla.keyPressEvent(self, e)
class inline_editor(QtGui.QFrame):
"""The wrapper containing the editor and additional controls"""
changed = QtCore.pyqtSignal()
applied = QtCore.pyqtSignal()
def __init__(self, experiment, notification=None, syntax=None):
"""
Constructor
Arguments:
experiment -- the opensesame experiment
Keywords arguments:
notification -- a short notification message (default=None)
syntax -- the syntax highlighter 'python', 'opensesame' or None
(default=None)
main_window -- the QtOpenSesame main window
"""
QtGui.QFrame.__init__(self)
self.experiment = experiment
self.setFrameStyle(QtGui.QFrame.NoFrame)
self.edit = scintilla(self, syntax=syntax)
self.edit.focusLost.connect(self.changed.emit)
self.search = QtGui.QLineEdit()
self.search.setMaximumWidth(150)
self.search.returnPressed.connect(self.perform_search)
self.search.setToolTip(_("Enter a search term"))
self.search_button = QtGui.QPushButton(self.experiment.icon("search"), \
"")
self.search_button.setIconSize(QtCore.QSize(16, 16))
self.search_button.setToolTip(_("Search"))
self.search_button.clicked.connect(self.perform_search)
self.replace_button = QtGui.QPushButton( \
self.experiment.icon("replace"), "")
self.replace_button.setIconSize(QtCore.QSize(16, 16))
self.replace_button.setToolTip(_("Replace"))
self.replace_button.clicked.connect(self.perform_replace)
self.indent_button = QtGui.QPushButton(self.experiment.icon("indent"), \
"")
self.indent_button.setIconSize(QtCore.QSize(16, 16))
self.indent_button.setToolTip(_("Indent one level (tab)"))
self.indent_button.clicked.connect(self.indent)
self.unindent_button = QtGui.QPushButton( \
self.experiment.icon("unindent"), "")
self.unindent_button.setIconSize(QtCore.QSize(16, 16))
self.unindent_button.setToolTip(_("Unindent one level (super + tab)"))
self.unindent_button.clicked.connect(self.unindent)
self.modified = self.experiment.label_image("unsaved_changes")
self.modified.setToolTip(_("Press Alt + A to apply unsaved changes"))
self.modified.hide()
self.apply = QtGui.QPushButton(self.experiment.icon("apply"), \
_("Apply"))
self.apply.setToolTip(_("Press Alt + A to apply unsaved changes"))
self.apply.setIconSize(QtCore.QSize(16, 16))
self.apply.clicked.connect(self._apply)
search_widget = QtGui.QWidget()
search_hbox = QtGui.QHBoxLayout(search_widget)
search_hbox.addWidget(self.search)
search_hbox.addWidget(self.search_button)
search_hbox.addWidget(self.replace_button)
search_hbox.addWidget(self.indent_button)
search_hbox.addWidget(self.unindent_button)
if notification != None:
search_hbox.addWidget(QtGui.QLabel("%s" % \
notification))
search_hbox.addStretch()
search_hbox.addWidget(self.modified)
search_hbox.addWidget(self.apply)
search_hbox.setContentsMargins(0, 0, 0, 0)
main_widget = QtGui.QFrame()
main_widget.setFrameStyle(QtGui.QFrame.StyledPanel | \
QtGui.QFrame.Sunken)
main_hbox = QtGui.QHBoxLayout(main_widget)
main_hbox.setSpacing(0)
main_hbox.setMargin(0)
main_hbox.addWidget(self.edit)
vbox = QtGui.QVBoxLayout(self)
vbox.addWidget(main_widget)
vbox.addWidget(search_widget)
vbox.setSpacing(4)
vbox.setMargin(0)
self.toolbar_hbox = search_hbox
def _apply(self):
"""When apply is clicked, two signals are sent"""
self.changed.emit()
self.applied.emit()
def perform_search(self, event=None, term=None):
"""
Select the text based on the search term
Keywords arguments:
term -- the search term or None to use the search input (default=None)
Returns:
True if the term was found, False otherwise
"""
if term == None:
term = self.search.text()
return self.edit.findFirst(term, False, False, False, True)
def perform_replace(self):
"""Shows the search/replace dialog"""
replace_dialog(self).exec_()
def getText(self):
"""
Returns:
The contents of the editor
"""
return self.edit.toPlainText()
def setText(self, text):
"""
Sets the contents of the editor
Arguments:
text -- the new contents
"""
self.edit.setPlainText(text)
def isModified(self):
"""
Check if the editor has been modified
Returns:
True if modified, False otherwise
"""
return self.edit.isModified()
def setModified(self, modified=True):
"""
Set the modified status of the editor
Keywords arguments:
modified -- the modified status (default=True)
"""
self.modified.setVisible(modified)
self.edit.setModified(modified)
if modified and not self.experiment.main_window.unsaved_changes:
self.experiment.main_window.set_unsaved()
def indent(self):
"""Indent the current line or selection by one level"""
self.selection_do(self.edit.indent)
def unindent(self):
"""Indent the current line or selection by one level"""
self.selection_do(self.edit.unindent)
def selection_do(self, func):
"""
Call a function for the current line or each line from the selection
Arguments:
func -- the function to be called
"""
lf, _if, lt, it = self.edit.getSelection()
if lf < 0:
lf = self.edit.getCursorPosition()[0]
lt = lf
for i in range(lf, lt+1):
func(i)
opensesame-0.27.4/libqtopensesame/widgets/start_new_widget.py 0000664 0001750 0001750 00000006734 12061663322 027012 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.ui.start_new_widget_ui import Ui_widget_start_new
from libqtopensesame.misc import template_info
import random
import os
class start_new_widget(QtGui.QWidget):
"""Start new dialog presented when starting with a clean experiment"""
def __init__(self, main_window, start=False):
"""
Constructor
Arguments:
main_window -- a the main ui
Keyword arguments:
start -- indicates whether the widget is opened because OpenSesame has
started (True) or because the new button has been clicked
(False) (default=True)
"""
QtGui.QDialog.__init__(self, main_window)
self.main_window = main_window
self.ui = Ui_widget_start_new()
self.ui.setupUi(self)
self.ui.widget_credits.initialize(self.main_window)
self.main_window.theme.apply_theme(self)
if start:
self.tab_name = '__start_wizard__'
else:
self.tab_name = '__new_wizard__'
# Initialize templates
for path, desc in template_info.templates:
try:
path = self.main_window.experiment.resource(path)
except:
continue
item = QtGui.QListWidgetItem(self.ui.list_templates)
item.setText(desc)
item.file = path
item.setIcon(self.main_window.experiment.icon("wizard"))
self.ui.list_templates.addItem(item)
self.ui.list_templates.setCurrentRow(0)
self.ui.list_templates.itemDoubleClicked.connect(self.open_template)
# Initialize recent
if len(self.main_window.recent_files) == 0:
self.ui.list_recent.hide()
self.ui._label_recent.hide()
else:
for f in self.main_window.recent_files:
item = QtGui.QListWidgetItem(self.ui.list_recent)
item.setText(os.path.basename(f))
item.file = f
item.setIcon(self.main_window.experiment.icon("experiment"))
self.ui.list_recent.setCurrentRow(0)
self.ui.list_recent.itemDoubleClicked.connect(self.open_recent)
# Connect buttons
self.ui.button_browse.clicked.connect(self.main_window.open_file)
self.ui.button_osdoc.clicked.connect( \
self.main_window.ui.tabwidget.open_osdoc)
self.ui.button_forum.clicked.connect( \
self.main_window.ui.tabwidget.open_forum)
self.ui.button_cancel.clicked.connect(self.cancel)
# Show the correct header
if start:
self.ui.widget_header_new.hide()
else:
self.ui.widget_header_start.hide()
def cancel(self):
"""Cancel the start_new_wizard"""
self.main_window.ui.tabwidget.close_current()
self.main_window.ui.tabwidget.open_general()
def open_template(self):
"""Open the selected template"""
self.main_window.open_file(path= \
self.ui.list_templates.currentItem().file, add_to_recent=False)
self.close()
def open_recent(self):
"""Open the selected file"""
item = self.ui.list_recent.currentItem()
if item != None:
self.main_window.open_file(path= \
self.ui.list_recent.currentItem().file)
self.close()
opensesame-0.27.4/libqtopensesame/widgets/toolbar_items.py 0000664 0001750 0001750 00000011710 12061663322 026272 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
import libopensesame.plugins
from libopensesame import debug
from libqtopensesame.misc import config, _
class widget_item(QtGui.QLabel):
"""A draggable toolbar icon"""
def __init__(self, pixmap, item, main_window):
"""
Constructor
Arguments:
icon -- a QIcon
item -- the item name
main_window -- the main window
"""
self.main_window = main_window
self.item = item
self.pixmap = pixmap
QtGui.QLabel.__init__(self)
self.setMargin(6)
self.setToolTip( \
_("Drag this %s item to the intended location in the overview area or into the item list of a sequence tab") \
% self.item)
self.setCursor(QtGui.QCursor(QtCore.Qt.OpenHandCursor))
self.setPixmap(self.pixmap)
def mouseMoveEvent(self, e):
"""
Start a drag operation and drop it if it was accepted by item overview
Arguments:
e -- a mouse event
"""
if e.buttons() != QtCore.Qt.LeftButton:
return
mimedata = QtCore.QMimeData()
mimedata.setText("__osnew__ %s" % self.item)
drag = QtGui.QDrag(self)
drag.setMimeData(mimedata)
drag.setHotSpot(e.pos() - self.rect().topLeft())
drag.setPixmap(self.pixmap)
if drag.start(QtCore.Qt.CopyAction) == QtCore.Qt.CopyAction:
if self.item == "loop":
self.main_window.drop_item(self.main_window.add_loop)
elif self.item == "sequence":
self.main_window.drop_item(self.main_window.add_sequence)
else:
self.main_window.drop_item(self.item)
else:
debug.msg("drop cancelled")
class toolbar_label(QtGui.QFrame):
"""A toolbar label"""
def __init__(self, label):
"""
Constructor
Arguments:
label -- the text for the label
"""
QtGui.QWidget.__init__(self)
l = QtGui.QLabel(label)
l.setMaximumWidth(90)
l.setIndent(5)
l.setWordWrap(True)
hbox = QtGui.QHBoxLayout()
hbox.addWidget(l)
hbox.setMargin(0)
self.setLayout(hbox)
class toolbar_items(QtGui.QToolBar):
"""This class implements the drag-and-droppable item toolbar"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- parent widget
"""
QtGui.QToolBar.__init__(self, parent)
self.main_window = None
self.orientationChanged.connect(self.build)
def add_content(self, content):
"""
Add double rows of content to the toolbar
Arguments:
content -- a list of content widgets
"""
if self.orientation() == QtCore.Qt.Horizontal:
for c in content:
self.addWidget(c)
else:
i = 0
for c in content:
if i % 2 == 0:
if i > 0:
self.addWidget(w)
l = QtGui.QHBoxLayout()
l.setSpacing(16)
w = QtGui.QWidget()
w.setLayout(l)
c.setMargin(0)
l.addWidget(c)
i += 1
if i % 2 == 1:
l.addStretch()
self.addWidget(w)
def build(self, dummy=None):
"""
Populate the toolbar with items (core and plugins)
Keywords arguments:
dummy -- a dummy argument (default=None)
"""
# Only do something if the main_window has been attached
if self.main_window == None:
return
# Remove old items
self.clear()
if self.orientation() == QtCore.Qt.Vertical:
self.addWidget(toolbar_label(_("Commonly used")))
# Add the core items
content = []
for item in self.main_window.experiment.core_items:
content.append(widget_item(self.main_window.theme.qpixmap(item, \
size=config.get_config("toolbar_size")), item, \
self.main_window))
self.add_content(content)
# Create a dictionary of plugins by category. We also maintain a list
# to preserve the order of the categories.
cat_list = []
cat_dict = {}
for plugin in libopensesame.plugins.list_plugins():
cat = libopensesame.plugins.plugin_category(plugin)
if cat not in cat_dict:
cat_dict[cat] = []
cat_list.append(cat)
cat_dict[cat].append(plugin)
# Add the plugins
for cat in cat_list:
self.addSeparator()
if self.orientation() == QtCore.Qt.Vertical:
self.addWidget(toolbar_label("%s" % cat))
content = []
for plugin in cat_dict[cat]:
debug.msg("adding plugin '%s'" % plugin)
if config.get_config("toolbar_size") == 16:
pixmap = QtGui.QPixmap( \
libopensesame.plugins.plugin_icon_small(plugin))
else:
pixmap = QtGui.QPixmap( \
libopensesame.plugins.plugin_icon_large(plugin))
content.append(widget_item(pixmap, plugin, self.main_window))
self.add_content(content)
opensesame-0.27.4/libqtopensesame/widgets/loop_table.py 0000664 0001750 0001750 00000004156 12061663322 025555 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from libqtopensesame.widgets import good_looking_table
from PyQt4 import QtCore, QtGui
class loop_table(good_looking_table.good_looking_table):
"""The looptable extends the QtTableWidget to allow copying and pasting"""
def __init__(self, loop, rows, columns, parent=None):
"""
Constructor
Arguments:
loop -- the loop item
rows -- the nr of rows
columns -- the nr of columns
Keyword arguments:
parent -- parent QWidget (default=None)
"""
self.pos = None
self.loop = loop
self.lock = False
icons = {}
icons["cut"] = self.loop.experiment.icon("cut")
icons["copy"] = self.loop.experiment.icon("copy")
icons["paste"] = self.loop.experiment.icon("paste")
icons["clear"] = self.loop.experiment.icon("clear")
good_looking_table.good_looking_table.__init__(self, \
rows, columns, icons, parent)
self.cellChanged.connect(self.apply_changes)
def paste(self):
"""Paste data from the clipboard into the table"""
self.lock = True
good_looking_table.good_looking_table.paste(self)
self.lock = False
self.apply_changes()
def _clear(self):
"""Clear the table"""
self.lock = True
good_looking_table.good_looking_table._clear(self)
self.lock = False
self.apply_changes()
def apply_changes(self):
"""
Apply changes to the table and make sure that the cursor is restored to
its previous position
"""
if self.lock:
return
self.loop.apply_edit_changes()
opensesame-0.27.4/libqtopensesame/widgets/font_widget.py 0000664 0001750 0001750 00000010372 12061663322 025743 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.ui import font_widget_ui
class font_widget(QtGui.QWidget):
"""A font selection widget"""
max_size = 64
font_list = ['mono', 'sans', 'serif', 'other ...']
def __init__(self, parent=None):
"""
Constructor
Arguments:
experiment -- the experiment
Keywords arguments:
parent -- the parent QWidget (default=None)
"""
QtGui.QWidget.__init__(self, parent)
self.ui = font_widget_ui.Ui_font_widget()
self.ui.setupUi(self)
def _apply(self):
"""Apply the controls"""
self.family = self.ui.combobox_family.currentText()
self.size = self.ui.spinbox_size.value()
self.italic = self.ui.checkbox_italic.isChecked()
self.bold = self.ui.checkbox_bold.isChecked()
self.ui.label_example.setFont(self.get_font())
self.emit(QtCore.SIGNAL("font_changed"))
def apply_family(self):
"""
Apply the controls and optionally present a full font selection dialog
if the user has selected 'other ...'
"""
if self.ui.combobox_family.currentText() == 'other ...':
font, ok = QtGui.QFontDialog.getFont(self.get_font())
if ok:
self.family = unicode(font.family())
else:
self.family = self.experiment.get('font_family')
self.update_family_combobox()
self._apply()
def get_font(self):
"""
Make a QFont based on the settings
Returns:
A QFont
"""
if self.bold:
weight = QtGui.QFont.Bold
else:
weight = QtGui.QFont.Normal
return QtGui.QFont(self.family, min(self.max_size, self.size), weight, \
self.italic)
def initialize(self, experiment, family=None, italic=None, bold=None, \
size=None):
"""
Initialize the widget
Arguments:
experiment -- an opensesame experiment
Keyword arguments:
family -- the font family or None to use experiment default
(default=None)
italic -- the font italic state or None to use experiment default
(default=None)
bold -- the font bold state or None to use experiment default
(default=None)
size -- the font size or None to use experiment default
(default=None)
"""
self.experiment = experiment
if family == None:
self.family = self.experiment.get('font_family')
else:
self.family = family
if italic == None:
self.italic = self.experiment.get('font_italic') == 'yes'
else:
self.italic = italic
if bold == None:
self.bold = self.experiment.get('font_bold') == 'yes'
else:
self.bold = bold
if size == None:
self.size = self.experiment.get('font_size')
else:
self.size = size
if self.ui.combobox_family.findText(self.family) < 0:
self.ui.combobox_family.addItem(self.family)
self.ui.combobox_family.setCurrentIndex( \
self.ui.combobox_family.findText(self.family))
self.ui.checkbox_italic.setChecked(self.italic)
self.ui.checkbox_bold.setChecked(self.bold)
self.ui.spinbox_size.setValue(self.size)
self._apply()
self.ui.combobox_family.currentIndexChanged.connect( \
self.apply_family)
self.ui.checkbox_italic.toggled.connect(self._apply)
self.ui.checkbox_bold.toggled.connect(self._apply)
self.ui.spinbox_size.valueChanged.connect(self._apply)
def update_family_combobox(self):
"""Update the family combobox to include a custom font"""
self.ui.combobox_family.currentIndexChanged.disconnect()
self.ui.combobox_family.clear()
l = self.font_list[:]
if self.family not in l:
l += [self.family]
self.ui.combobox_family.insertItems(0, l)
self.ui.combobox_family.setCurrentIndex( \
self.ui.combobox_family.findText(self.family))
self.ui.combobox_family.currentIndexChanged.connect( \
self.apply_family)
opensesame-0.27.4/libqtopensesame/widgets/header_widget.py 0000664 0001750 0001750 00000006606 12173713501 026231 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from PyQt4 import QtCore, QtGui
from libopensesame import debug
from libqtopensesame.misc import _
class header_widget(QtGui.QWidget):
"""Editable labels for the item's name and description"""
def __init__(self, item):
"""
Constructor
Arguments:
item -- the item to provide a header for
"""
QtGui.QWidget.__init__(self)
self.setCursor(QtCore.Qt.IBeamCursor)
self.setToolTip(_(u"Click to edit"))
self.item = item
self.label_name = QtGui.QLabel()
self.label_name.id = u"name"
self.edit_name = QtGui.QLineEdit()
self.edit_name.editingFinished.connect(self.restore_name)
self.edit_name.hide()
self.label_desc = QtGui.QLabel()
self.label_desc.id = u"desc"
self.edit_desc = QtGui.QLineEdit()
self.edit_desc.editingFinished.connect(self.restore_desc)
self.edit_desc.hide()
vbox = QtGui.QVBoxLayout()
vbox.setContentsMargins(8, 0, 0, 0)
vbox.setSpacing(0)
vbox.addWidget(self.label_name)
vbox.addWidget(self.edit_name)
vbox.addWidget(self.label_desc)
vbox.addWidget(self.edit_desc)
self.refresh()
self.setLayout(vbox)
def refresh(self):
"""Update the header"""
self.edit_name.setText(self.item.name)
self.label_name.setText( \
u"%s - %s Click to edit" \
% (self.item.name, self.item.item_type.replace(u"_", u" ").title()))
self.edit_desc.setText(self.item.description)
self.label_desc.setText(self.item.description)
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()
def restore_desc(self):
"""Apply the description change and revert the edit back to the label"""
self.item.apply_edit_changes()
self.refresh()
self.label_desc.show()
self.edit_desc.hide()
def mousePressEvent(self, event):
"""
Change the label into an edit for the name or
the description, depending on where has been
clicked
Arguments:
event -- the mouseClickEvent
"""
target = self.childAt(event.pos())
if target != None and hasattr(target, u"id"):
if target.id == u"name":
self.restore_desc()
self.label_name.hide()
self.edit_name.show()
self.edit_name.selectAll()
self.edit_name.setFocus()
else:
self.restore_name()
self.label_desc.hide()
self.edit_desc.show()
self.edit_desc.selectAll()
self.edit_desc.setFocus()
opensesame-0.27.4/libqtopensesame/widgets/__init__.py 0000664 0001750 0001750 00000001331 12061663322 025164 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
opensesame-0.27.4/libqtopensesame/widgets/draggables.py 0000664 0001750 0001750 00000016165 12061663322 025533 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
import sip
from PyQt4 import QtGui, QtCore
from libqtopensesame.widgets import item_context_menu
from libqtopensesame.misc import _
drop_target = None
class draggable_handle(QtGui.QLabel):
"""The draggable handles for re-ordering the list"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- the parent widget
"""
QtGui.QLabel.__init__(self)
self.setPixmap( \
parent._list.sequence.experiment.main_window.theme.qpixmap( \
"handle"))
self.setAcceptDrops(True)
self.setCursor(QtCore.Qt.OpenHandCursor)
self.container = parent
self.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.setToolTip(_("Drag this item to re-order"))
def valid_drag(self, mime_data):
"""
Checks if mime data corresponds to a valid drag operation
Arguments:
mime_data -- the mime data
Returns:
True or False
"""
if mime_data.hasText():
l = mime_data.text().split(" ")
if len(l) == 2 and l[0] in ["__osdrag__", "__osnew__"]:
return True
return False
def index_from_mime_data(self, mime_data):
"""
Extract the item index from a mime data
Returns:
An item index or -1 if the mime data was invalid
"""
if mime_data.hasText():
l = mime_data.text().split(" ")
if len(l) == 2 and l[0] == "__osdrag__":
try:
return int(l[1])
except:
pass
return -1
def dragEnterEvent(self, e):
"""
Handle incoming drags
Arguments:
e -- a QDragEvent
"""
if self.valid_drag(e.mimeData()):
e.accept()
else:
e.ignore()
def dropEvent(self, e):
"""
Handle incoming drops
Arguments:
e -- a QDragEvent
"""
global drop_target
if self.valid_drag(e.mimeData()):
from_index = self.index_from_mime_data(e.mimeData())
if from_index >= 0:
e.accept()
self.container._list.sequence.move(from_index, \
self.container.index)
else:
drop_target = self.container._list.sequence.name, \
self.container.index, False
e.setDropAction(QtCore.Qt.CopyAction)
e.accept()
else:
e.ignore()
def mouseMoveEvent(self, e):
"""
Start drags
Arguments:
e -- a QMouseEvent
"""
mime_data = QtCore.QMimeData()
mime_data.setText("__osdrag__ %d" % self.container.index)
drag = QtGui.QDrag(self)
drag.setMimeData(mime_data)
drag.setHotSpot(e.pos() - self.rect().topLeft())
dropAction = drag.start(QtCore.Qt.MoveAction)
class run_if_edit(QtGui.QLineEdit):
"""Item 'run if' edit"""
def __init__(self, parent):
"""
Constructor
Arguments:
parent -- the parent container
"""
QtGui.QLineEdit.__init__(self, parent.item[1])
self.container = parent
self.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.editingFinished.connect(self.change)
self.setToolTip(_("Run this item only under the following conditions"))
def change(self):
"""Apply changes"""
self.container._list.sequence.set_run_if(self.container.index, \
self.text())
class open_button(QtGui.QPushButton):
"""A button containing the item icon and name"""
def __init__(self, item, parent):
"""
Constructor
Arguments:
item -- the item tuple (name, run_if)
parent -- the parent container
"""
item_type = parent._list.sequence.experiment.items[item[0]].item_type
icon = parent._list.sequence.experiment.icon(item_type)
QtGui.QPushButton.__init__(self, icon, item[0], parent)
self.setObjectName("sequence_open_button")
self.container = parent
self.item = item
self.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.setFlat(True)
self.setIconSize(QtCore.QSize(32,16))
self.clicked.connect(self.open_item_tab)
self.setToolTip(_("Click to edit this item"))
def open_item_tab(self):
"""Open the item's tab"""
self.container._list.sequence.experiment.items[self.item[0]].open_tab()
def mousePressEvent(self, e):
"""
Open the tab on a left click and show the context menu on a right click
Arguments:
e -- a QMouseEvent
"""
if e.button() == QtCore.Qt.LeftButton:
QtGui.QPushButton.mousePressEvent(self, e)
elif e.button() == QtCore.Qt.RightButton:
item = self.container._list.sequence.experiment.items[self.item[0]]
m = item_context_menu.item_context_menu("Item", self, item,
self.container._list.sequence.name, self.container.index)
m.popup(e.globalPos())
class draggable_widget_container(QtGui.QFrame):
"""A container for a single item"""
def __init__(self, parent, item, index):
"""
Constructor
Arguments:
parent -- the parent draggable_list
item -- the item tuple (name, run_if)
index -- the index of the item in the sequence
"""
QtGui.QFrame.__init__(self, parent)
self.setObjectName("sequence_container")
self.item = item
self.setFrameStyle(QtGui.QFrame.Panel)
self._list = parent
self.handle = draggable_handle(self)
self.run_if_edit = run_if_edit(self)
self.index = index
self._layout = QtGui.QHBoxLayout()
self._layout.addWidget(self.handle)
self._layout.addWidget(open_button(item, self))
self._layout.addStretch()
self._layout.addWidget(QtGui.QLabel(_("Run if")))
self._layout.addWidget(self.run_if_edit)
self.setLayout(self._layout)
self._layout.setContentsMargins(4, 4, 4, 4)
self.setMinimumSize(100,32)
self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding, \
QtGui.QSizePolicy.Fixed)
class draggable_list(QtGui.QWidget):
"""The main draggable list"""
def __init__(self, sequence):
"""
Constructor
Arguments:
sequence -- the parent sequence item
"""
QtGui.QWidget.__init__(self)
self.items = []
self.sequence = sequence
self._layout = QtGui.QVBoxLayout()
self._layout.setContentsMargins(4, 4, 4, 16)
self._layout.setSpacing(0)
self.setLayout(self._layout)
self.widgets = []
self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding, \
QtGui.QSizePolicy.MinimumExpanding)
def refresh(self):
"""Refresh the view"""
for widget in self.widgets:
self._layout.removeWidget(widget)
widget.hide()
del widget
self.widgets = []
for i in range(len(self.sequence.items)):
item_name = self.sequence.items[i][0]
if item_name not in self.sequence.experiment.items:
self.sequence.experiment.notify( \
_("Unkown item '%s' in sequence '%s'. You can fix this using the script editor.") \
% (item_name, self.sequence.name))
else:
widget = draggable_widget_container(self, \
self.sequence.items[i], i)
self.widgets.append(widget)
self._layout.addWidget(widget)
spacer = QtGui.QWidget()
self.widgets.append(spacer)
self._layout.addWidget(spacer)
opensesame-0.27.4/libqtopensesame/widgets/general_script_editor.py 0000664 0001750 0001750 00000004054 12061663322 030001 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.misc import _
from libqtopensesame.widgets.inline_editor import inline_editor
from libqtopensesame.ui.general_script_editor_ui import \
Ui_widget_general_script_editor
class general_script_editor(QtGui.QWidget):
"""The general script editor"""
def __init__(self, main_window):
"""
Constructor
Arguments:
main_window -- the main window
"""
self.main_window = main_window
QtGui.QWidget.__init__(self, main_window)
self.ui = Ui_widget_general_script_editor()
self.ui.setupUi(self)
self.ui.edit = inline_editor(self.main_window.experiment)
self.ui.edit.applied.connect(self._apply)
self.ui.layout_vbox.addWidget(self.ui.edit)
self.main_window.theme.apply_theme(self)
self.tab_name = '__general_script__'
def _apply(self):
"""Confirm and apply the script changes"""
resp = QtGui.QMessageBox.question(self.main_window, _('Apply?'), \
_('Are you sure you want to apply the changes to the general script?'), \
QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if resp == QtGui.QMessageBox.No:
return
self.main_window.dispatch.event_regenerate.emit(self.ui.edit.getText())
def on_activate(self):
"""Refresh the tab when it is activated"""
self.refresh()
def refresh(self):
"""Refresh the contents of the general script"""
self.ui.edit.setText(self.main_window.experiment.to_string())
opensesame-0.27.4/libqtopensesame/widgets/tree_overview.py 0000664 0001750 0001750 00000012116 12061663322 026315 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.widgets import draggables, item_context_menu
from libopensesame import debug
class tree_overview(QtGui.QTreeWidget):
"""The drag-and-droppable overview tree"""
def __init__(self, parent):
"""
Constructor
Arguments:
parent -- the parent item
"""
QtGui.QTreeWidget.__init__(self, parent)
def dragEnterEvent(self, e):
"""
Accept an incoming drag event
Arguments:
e -- a QDragEvent
"""
if e.mimeData().hasText():
e.setDropAction(QtCore.Qt.CopyAction)
e.accept()
else:
e.ignore()
def dragMoveEvent(self, e):
"""
Highlight the appropriate item while a drop is being moved
Arguments:
e -- a QDragEvent
"""
if e.mimeData().hasText():
e.setDropAction(QtCore.Qt.CopyAction)
for item in self.selectedItems():
item.setSelected(False)
item = self.itemAt(e.pos())
if item != None:
item.setSelected(True)
e.accept()
else:
e.ignore()
def dropEvent(self, e):
"""
Accept a drop event
Arguments:
e -- a QDragEvent
"""
if e.mimeData().hasText():
s = e.mimeData().text()
e.setDropAction(QtCore.Qt.CopyAction)
item = self.itemAt(e.pos())
if item == None:
e.ignore()
return
# Accept a drop on the toplevel item
if item.parent() == None:
self.main_window.experiment.notify( \
'You cannot change the entry point of the experiment!')
return
index = 0
while True:
item_name = unicode(item.text(0))
if item_name not in self.main_window.experiment.items:
e.ignore()
return
item_type = \
self.main_window.experiment.items[item_name].item_type
if item_type == "sequence":
break
index = item.parent().indexOfChild(item)
item = item.parent()
if item != None:
item.setSelected(True)
draggables.drop_target = item_name, index, True
e.accept()
else:
e.ignore()
else:
e.ignore()
def context_menu(self, item, pos=None):
"""
Present a context menu for an item.
Arguments:
item -- a QTreeWidgetItem
Keyword arguments:
A position for the top-left of the menu (default=None)
"""
target_item = item
item_name = unicode(target_item.text(0))
parent_item = target_item.parent()
if parent_item != None:
parent_name = unicode(parent_item.text(0))
else:
parent_name = None
index = None
if parent_name in self.main_window.experiment.items:
parent_type = \
self.main_window.experiment.items[parent_name].item_type
# If the parent is a sequence, get the position of the item in the
# sequence, because the name by itself is ambiguous since the name
# may occur multiple times in one sequence
if parent_type == "sequence":
index = 0
for index in range(parent_item.childCount()):
child = parent_item.child(index)
if child == target_item:
break
index += 1
if item_name not in self.main_window.experiment.items:
return
item = self.main_window.experiment.items[item_name]
m = item_context_menu.item_context_menu("Item", self, item, \
parent_name, index)
if pos == None:
m.popup(self.mapToGlobal(self.pos()))
else:
m.popup(pos)
def contextMenuEvent(self, e):
"""
Show a context menu at the cursor position
Arguments:
e -- the content menu event
"""
item = self.itemAt(e.pos())
self.context_menu(item, e.globalPos())
def keyPressEvent(self, e):
"""
Capture key presses to auto-activate selected items
Arguments:
e -- a QKeyEvent
"""
QtGui.QTreeWidget.keyPressEvent(self, e)
if e.key() in [QtCore.Qt.Key_Up, QtCore.Qt.Key_Down, \
QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown, QtCore.Qt.Key_Home, \
QtCore.Qt.Key_End, QtCore.Qt.Key_Return]:
self.main_window.open_item(self.currentItem())
elif e.key() == QtCore.Qt.Key_Space:
self.context_menu(self.currentItem())
def recursive_children(self, item):
"""
Get a list of unused items from the itemtree
Returns:
A list of items (strings) that are children of the parent item
"""
children = []
for i in range(item.childCount()):
child = item.child(i)
children.append(unicode(child.text(0)))
children += self.recursive_children(child)
return children
def unused_items(self):
"""
Get a list of unused items
Returns:
A list of unused items (names as strings)
"""
return self.main_window.ui.itemtree.recursive_children( \
self.main_window.ui.itemtree.topLevelItem( \
self.main_window.ui.itemtree.topLevelItemCount()-1))
opensesame-0.27.4/libqtopensesame/widgets/credits_widget.py 0000664 0001750 0001750 00000003677 12061663322 026444 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from libopensesame import misc
from libqtopensesame.misc import config
from libqtopensesame.ui.credits_widget_ui import Ui_widget_credits
from PyQt4 import QtGui, QtCore
class credits_widget(QtGui.QWidget):
"""A widget with the opensesame credits"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- the parent QWidget
"""
QtGui.QTabWidget.__init__(self, parent)
self.ui = Ui_widget_credits()
self.ui.setupUi(self)
def initialize(self, main_window):
self.main_window = main_window
self.main_window.theme.apply_theme(self)
self.ui.label_opensesame.setText(unicode( \
self.ui.label_opensesame.text()).replace("[version]", \
misc.version).replace("[codename]", misc.codename))
self.ui.label_website.mousePressEvent = self.open_website
self.ui.label_facebook.mousePressEvent = self.open_facebook
self.ui.label_twitter.mousePressEvent = self.open_twitter
def open_website(self, dummy=None):
"""Open the main website"""
misc.open_url(config.get_config("url_website"))
def open_facebook(self, dummy=None):
"""Open Facebook page"""
misc.open_url(config.get_config("url_facebook"))
def open_twitter(self, dummy=None):
"""Open Twitter page"""
misc.open_url(config.get_config("url_twitter"))
opensesame-0.27.4/libqtopensesame/widgets/webbrowser.py 0000664 0001750 0001750 00000006213 12173713501 025611 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui, QtWebKit
from libopensesame import debug
from libqtopensesame.ui import webbrowser_widget_ui
import os.path
import sys
class small_webview(QtWebKit.QWebView):
"""
A wrapper around QWebView too override the sizeHint, which prevents the
browser from resizing to small sizes
"""
def sizeHint(self):
"""
Give size hint
Returns:
A QSize
"""
return QtCore.QSize(100,100)
class webbrowser(QtGui.QWidget):
"""A simple browser tab"""
def __init__(self, parent):
"""
Constructor
Keyword arguments:
parent -- the parent QWidget (default=None)
"""
QtGui.QWidget.__init__(self, parent)
self.main_window = parent
self.ui = webbrowser_widget_ui.Ui_webbrowser_widget()
self.ui.setupUi(self)
self.ui.webview = small_webview(self)
self.ui.webview.loadProgress.connect(self.update_progressbar)
self.ui.webview.loadStarted.connect(self.load_started)
self.ui.webview.loadFinished.connect(self.load_finished)
self.ui.webview.urlChanged.connect(self.url_changed)
self.ui.layout_main.addWidget(self.ui.webview)
self.ui.button_back.clicked.connect(self.ui.webview.back)
self.ui.button_osdoc.clicked.connect(self.open_osdoc)
self.ui.button_forum.clicked.connect(self.open_forum)
self.main_window.theme.apply_theme(self)
def load(self, url):
"""
Load a webpage
Arguments:
url -- the webpage to load
"""
if url.endswith(u'.md'):
try:
import markdown
html = markdown.markdown(open(url).read())
except:
html = \
u'Python markdown must be installed to view this page. Sorry!'
self.ui.webview.setHtml(html, QtCore.QUrl(url))
else:
self.ui.webview.load(QtCore.QUrl(url))
def load_finished(self):
"""Hide the statusbar to indicate that loading is finished"""
self.ui.label_load_progress.setText('Done')
def update_progressbar(self, progress):
"""
Update the progressbar to indicate the load progress
Arguments:
progress -- the load progress
"""
self.ui.label_load_progress.setText('%d%%' % progress)
def load_started(self):
"""Show the statusbar to indicate that loading has started"""
self.ui.label_load_progress.setText('Starting ...')
def open_osdoc(self):
"""Open osdoc.cogsci.nl"""
self.load('http://osdoc.cogsci.nl/')
def open_forum(self):
"""Open forum.cogsci.nl"""
self.load('http://forum.cogsci.nl/')
def url_changed(self, url):
"""Update the url bat"""
self.ui.edit_url.setText(url.toString())
opensesame-0.27.4/libqtopensesame/widgets/backend_settings.py 0000664 0001750 0001750 00000007115 12061663322 026742 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
import sip
from libqtopensesame.misc import _
from libqtopensesame.ui.backend_settings_ui import \
Ui_widget_backend_settings
class backend_settings(QtGui.QWidget):
def __init__(self, main_window):
self.main_window = main_window
QtGui.QWidget.__init__(self, main_window)
self.ui = Ui_widget_backend_settings()
self.ui.setupUi(self)
self.main_window.theme.apply_theme(self)
self.tab_name = '__backend_settings__'
for backend_type in ["canvas", "keyboard", "mouse", "synth", \
"sampler"]:
backend = self.main_window.experiment.get("%s_backend" \
% backend_type)
exec("from openexp._%s.%s import %s as _backend" % ( \
backend_type, backend, backend))
group = eval("self.ui.group_%s" % backend_type)
layout = eval("self.ui.layout_%s" % backend_type)
label = eval("self.ui.label_%s" % backend_type)
# Horribly ugly wayo clear the previous settings
while layout.count() > 1:
w = layout.itemAt(1)
layout.removeItem(w)
w.widget().hide()
sip.delete(w)
if not hasattr(_backend, "settings") or _backend.settings == \
None:
label.setText(_("No settings for %s") % backend)
else:
label.setText(_("Settings for %s:") % backend)
layout.addWidget(settings_widget( \
self.main_window.experiment, _backend.settings, self))
class settings_edit(QtGui.QLineEdit):
"""An edit widget for a single variable"""
def __init__(self, experiment, var, val, parent=None):
"""
Constructor
Arguments:
experiment -- the experiment
var -- the variable name
val -- the variable value
Keywords arguments:
parent -- parent QWidget (default=None)
"""
QtGui.QLineEdit.__init__(self, experiment.unistr(val))
self._parent = parent
self.var = var
self.experiment = experiment
self.editingFinished.connect(self.apply_setting)
def apply_setting(self):
"""Apply changes"""
self.experiment.set(self.var, self.experiment.sanitize(self.text()))
self._parent._parent.main_window.refresh()
class settings_widget(QtGui.QWidget):
"""A widget containing a number of settings"""
def __init__(self, experiment, settings, parent=None):
"""
Constructor
Arguments:
experiment -- the experiment
settings -- the settings dictionary
Keywords arguments:
parent -- parent QWidget (default=None)
"""
QtGui.QWidget.__init__(self, parent)
self._parent = parent
self.experiment = experiment
self.settings = settings
self.layout = QtGui.QFormLayout(self)
self.layout.setFieldGrowthPolicy(QtGui.QFormLayout.FieldsStayAtSizeHint)
self.setLayout(self.layout)
for var, desc in settings.items():
if self.experiment.has(var):
val = self.experiment.get(var)
else:
val = desc["default"]
label = QtGui.QLabel()
label.setText("%(name)s
%(description)s" % desc)
label.setTextFormat(QtCore.Qt.RichText)
edit = settings_edit(self.experiment, var, val, self)
self.layout.addRow(label, edit)
opensesame-0.27.4/libqtopensesame/widgets/sketchpad_widget.py 0000664 0001750 0001750 00000072711 12214350640 026744 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
import math
import os
import numbers
from libopensesame import exceptions, debug
from libqtopensesame.ui import sketchpad_widget_ui, gabor_dialog_ui, \
noise_patch_dialog_ui
from libqtopensesame.widgets import pool_widget
from libqtopensesame.misc import _
import openexp.canvas
from PyQt4 import QtCore, QtGui
class remove_item_button(QtGui.QPushButton):
"""A button to remove items from the sketchpad"""
def __init__(self, sketchpad_widget, item):
"""
Constructor
Arguments:
sketchpad_widget -- the sketchpad widget
item -- the item of the sketchpad widget
"""
self.sketchpad_widget = sketchpad_widget
self.item = item
QtGui.QPushButton.__init__(self, \
self.sketchpad_widget.sketchpad.experiment.icon("delete"), "")
self.clicked.connect(self.remove_item)
self.setIconSize(QtCore.QSize(16,16))
def remove_item(self):
"""Is called when the remove button is clicked"""
self.sketchpad_widget.sketchpad.items.remove(self.item)
self.sketchpad_widget.refresh()
class edit_item_button(QtGui.QPushButton):
"""A button to edit items in the sketchpad"""
def __init__(self, sketchpad_widget, item):
"""
Constructor
Arguments:
sketchpad_widget -- the sketchpad widget
item -- the item of the sketchpad widget
"""
self.sketchpad_widget = sketchpad_widget
self.item = item
QtGui.QPushButton.__init__(self, \
self.sketchpad_widget.sketchpad.experiment.icon("edit"), "")
self.clicked.connect(self.edit_item)
self.setIconSize(QtCore.QSize(16,16))
def edit_item(self):
"""Is called when the edit button is clicked"""
self.sketchpad_widget.scene.edit_item( \
self.sketchpad_widget.sketchpad.fix_coordinates(self.item))
self.sketchpad_widget.sketchpad.apply_edit_changes()
self.sketchpad_widget.refresh()
class canvas(QtGui.QGraphicsScene):
"""The QGraphicsScene on which the sketchpad is drawn"""
def __init__(self, sketchpad_widget, parent=None):
"""
Constructor
Arguments:
sketchpad_widget -- the sketchpad_widget of which the canvas is part
Keyword arguments:
parent -- the parent QWidget (default=None)
"""
self.sketchpad_widget = sketchpad_widget
self.grid = 10
self.r = 4
self.pen = pen = QtGui.QPen()
self.grid_color = "green"
self.pen.setColor(QtGui.QColor(self.grid_color))
self.oneshot = False
self.from_pos = None
self.grid_list = []
QtGui.QGraphicsScene.__init__(self, parent)
def cursor_pos(self, e):
"""
Gets the position of the mouse cursor. This position
takes into account the reference frame (relative/ absolute)
and the grid
Arguments:
e -- a QMouseEvent
Returns:
An (x, y) tuple with the the coordinates of the mouse cursor
"""
pos = e.scenePos().toPoint()
x = pos.x() + 0.5 * self.grid
y = pos.y() + 0.5 * self.grid
if self.sketchpad_widget.sketchpad.get("coordinates") == "relative":
x -= 0.5 * self.sketchpad_widget.sketchpad.get("width")
y -= 0.5 * self.sketchpad_widget.sketchpad.get("height")
x = x - x % self.grid
y = y - y % self.grid
return x, y
def mouseMoveEvent(self, e):
"""
Update the text widget with the cursor position
Arguments:
e -- a QMouseEvent
"""
x, y = self.cursor_pos(e)
if x == None:
text = "(0, 0)"
else:
text = "(%d, %d)" % (x, y)
self.sketchpad_widget.ui.label_mouse_pos.setText(text)
def mousePressEvent(self, e):
"""
Handle mouse presses to start/ finish drawing
or present a context menu
Arguments:
e -- a QMouseEvent
"""
if e.button() == QtCore.Qt.RightButton:
self.context_menu(e)
else:
self.draw(e)
def draw(self, e):
"""
Handle drawing operations
Arguments:
e -- a QMouseEvent
"""
x, y = self.cursor_pos(e)
if x == None:
return
if self.sketchpad_widget.sketchpad.get("coordinates") == "relative":
x += 0.5 * self.sketchpad_widget.sketchpad.get("width")
y += 0.5 * self.sketchpad_widget.sketchpad.get("height")
if x < 0 or y < 0 or x >= self.sketchpad_widget.sketchpad.get("width") \
or y >= self.sketchpad_widget.sketchpad.get("height"):
self.sketchpad_widget.ui.label_mouse_pos.setText( \
_("(Out of sketchpad)"))
return
if self.from_pos == None and not self.oneshot:
self.addEllipse(x - self.r, y - self.r, 2 * self.r, 2 * self.r, \
self.pen)
self.from_pos = x, y
else:
pos = self.from_pos
self.from_pos = None
self.sketchpad_widget.add(pos, (x, y))
def context_menu(self, e):
"""
Show the context menu
Arguments:
e -- a QMouseEvent
"""
# First clear the grid, so we don't select the grid items
for l in self.grid_list:
self.removeItem(l)
self.grid_list = []
# Get the item under the cursor
item = self.itemAt(e.scenePos())
if item != None:
# Get the corresponding item from the sketchpad_widget
for g, _item in self.sketchpad_widget.item_list:
if g == item:
# Draw a highlight box
brush = QtGui.QBrush()
brush.setColor(QtGui.QColor(self.grid_color))
brush.setStyle(QtCore.Qt.Dense2Pattern)
# For some items the boundingrect does not appear to work
# correctly, so we have to use the pos() function
x = max(item.pos().x(), item.boundingRect().x()) - 4
y = max(item.pos().y(), item.boundingRect().y()) - 4
w = item.boundingRect().width() + 8
h = item.boundingRect().height() + 8
l = self.addRect(x, y, w, h, brush = brush)
l.setOpacity(0.25)
# Show the context menu
menu = QtGui.QMenu()
menu.addAction( \
self.sketchpad_widget.sketchpad.experiment.icon( \
"delete"), _("Delete"))
menu.addAction( \
self.sketchpad_widget.sketchpad.experiment.icon( \
"edit"), _("Edit"))
action = menu.exec_(e.screenPos())
# Execute the chosen action
if action != None:
if unicode(action.text()) == _("Delete"):
self.delete_item(_item)
elif unicode(action.text()) == _("Edit"):
self.edit_item(_item)
self.sketchpad_widget.sketchpad.apply_edit_changes()
self.sketchpad_widget.refresh()
def delete_item(self, item):
"""
Delete an item from the sketchpad
Arguments:
item -- the item to be deleted
"""
s = self.sketchpad_widget.sketchpad.item_to_string(item)
# Walk through all items and find the matching one
for i in self.sketchpad_widget.sketchpad.items:
# We have to fix the coordinates, because the items in the widget
# are not relative, whereas the items in the sketchpats are
j = self.sketchpad_widget.sketchpad.fix_coordinates(i)
# If the strings match, delete it!
if self.sketchpad_widget.sketchpad.item_to_string(j) == s:
self.sketchpad_widget.sketchpad.items.remove(i)
break
def edit_item(self, item):
"""
Present an input dialog to edit an item
Arguments:
item -- the item to edit
"""
s = self.sketchpad_widget.sketchpad.item_to_string( \
self.sketchpad_widget.sketchpad.unfix_coordinates(item))
s = self.sketchpad_widget.sketchpad.experiment.text_input( \
_("Edit sketchpad element"), message=_("Element script"), \
content=s)
if s == None:
return
tmp = self.sketchpad_widget.sketchpad.items[:] # Keep a backup
self.delete_item(item)
try:
self.sketchpad_widget.sketchpad.from_string(s)
except exceptions.script_error as e:
self.sketchpad_widget.sketchpad.items = tmp
self.sketchpad_widget.sketchpad.experiment.notify(e)
def draw_grid(self):
"""Draw the grid"""
self.grid_list = []
w = self.sketchpad_widget.sketchpad.experiment.get("width")
h = self.sketchpad_widget.sketchpad.experiment.get("height")
pen = QtGui.QPen()
pen.setWidth(1)
pen.setColor(QtGui.QColor(self.grid_color))
x1 = 0
x2 = w
y1 = 0
y2 = h
if self.sketchpad_widget.sketchpad.get("coordinates") == "relative":
x1 -= w / 2
y1 -= h / 2
x1 = x1 - x1 % self.grid
y1 = y1 - y1 % self.grid
x1 += w / 2
y1 += h / 2
if x1 < w / 2:
x1 += self.grid
if y1 < h / 2:
y1 += self.grid
for x in range(x1, x2, self.grid):
if x == w / 2:
pen.setWidth(3)
l = self.addLine(x, y1, x, y2, pen)
l.setOpacity(0.25)
self.grid_list.append(l)
if x == w / 2:
pen.setWidth(1)
for y in range(y1, y2, self.grid):
if y == h / 2:
pen.setWidth(3)
l = self.addLine(x1, y, x2, y, pen)
l.setOpacity(0.25)
self.grid_list.append(l)
if y == h / 2:
pen.setWidth(1)
class sketchpad_widget(QtGui.QWidget):
"""A custom widget contain the sketchpad canvas controls, etc."""
def __init__(self, sketchpad, parent=None, embed=True):
"""
Constructor
Arguments:
sketchpad -- a libopensesame.sketchpad instance
Keyword arguments:
parent -- a parent widget (default=None)
"""
QtGui.QWidget.__init__(self, parent)
# Setup the UI
self.ui = sketchpad_widget_ui.Ui_sketchpad_widget()
self.ui.setupUi(self)
self.ui.view.setViewportMargins(0, 0, 0, 0)
self.sketchpad = sketchpad
self.embed = embed
self.zoom = 1.0
self.scene = canvas(self)
self.ui.view.setScene(self.scene)
self.item_list = []
self.vbox_items = QtGui.QVBoxLayout()
self.ui.widget_items.setLayout(self.vbox_items)
# Initialize custom color and font widgets
self.ui.edit_color.initialize(self.sketchpad.experiment, color= \
self.sketchpad.get('foreground', _eval=False))
QtCore.QObject.connect(self.ui.edit_color, QtCore.SIGNAL( \
"set_color"), self.set_tool)
self.ui.widget_font.initialize(self.sketchpad.experiment)
QtCore.QObject.connect(self.ui.widget_font, QtCore.SIGNAL( \
"font_changed"), self.set_tool)
self.ui.button_line.clicked.connect(self.set_line)
self.ui.button_rect.clicked.connect(self.set_rect)
self.ui.button_ellipse.clicked.connect(self.set_ellipse)
self.ui.button_circle.clicked.connect(self.set_circle)
self.ui.button_arrow.clicked.connect(self.set_arrow)
self.ui.button_textline.clicked.connect(self.set_textline)
self.ui.button_fixdot.clicked.connect(self.set_fixdot)
self.ui.button_image.clicked.connect(self.set_image)
self.ui.button_gabor.clicked.connect(self.set_gabor)
self.ui.button_noise_patch.clicked.connect(self.set_noise)
self.ui.button_edit_script.clicked.connect(self.edit_script)
self.ui.spin_penwidth.valueChanged.connect(self.set_tool)
self.ui.spin_zoom.valueChanged.connect(self.set_tool)
self.ui.spin_scale.valueChanged.connect(self.set_tool)
self.ui.spin_grid.valueChanged.connect(self.set_tool)
self.ui.spin_arrow_size.valueChanged.connect(self.set_tool)
self.ui.checkbox_fill.stateChanged.connect(self.set_tool)
self.ui.checkbox_center.stateChanged.connect(self.set_tool)
self.ui.checkbox_html.stateChanged.connect(self.set_tool)
self.ui.checkbox_show_grid.stateChanged.connect(self.set_tool)
self.ui.edit_show_if.editingFinished.connect(self.set_tool)
self.set_line()
self.refresh()
self.sketchpad.experiment.main_window.theme.apply_theme(self)
def edit_script(self):
"""
Show the edit script tab and, if not embedded, close the current window
"""
if not self.embed:
self.parent().accept()
self.sketchpad.open_script_tab()
def unset_all(self):
"""Untoggle all buttons"""
self.ui.button_line.setChecked(False)
self.ui.button_rect.setChecked(False)
self.ui.button_ellipse.setChecked(False)
self.ui.button_circle.setChecked(False)
self.ui.button_arrow.setChecked(False)
self.ui.button_textline.setChecked(False)
self.ui.button_fixdot.setChecked(False)
self.ui.button_image.setChecked(False)
self.ui.button_gabor.setChecked(False)
self.ui.button_noise_patch.setChecked(False)
self.ui.edit_color.hide()
self.ui.spin_penwidth.hide()
self.ui.spin_scale.hide()
self.ui.spin_arrow_size.hide()
self.ui.checkbox_fill.hide()
self.ui.checkbox_center.hide()
self.ui.checkbox_html.hide()
self.ui.widget_font.hide()
self.ui.label_options.hide()
self.ui.label_color.hide()
self.ui.label_penwidth.hide()
self.ui.label_scale.hide()
self.ui.label_arrow_size.hide()
def set_rect(self):
"""Activate the rect button"""
self.unset_all()
self.ui.button_rect.setChecked(True)
self.ui.edit_color.show()
self.ui.spin_penwidth.show()
self.ui.checkbox_fill.show()
self.ui.label_color.show()
self.ui.label_penwidth.show()
self.set_tool()
def set_ellipse(self):
"""Activate the ellipse button"""
self.unset_all()
self.ui.button_ellipse.setChecked(True)
self.ui.edit_color.show()
self.ui.spin_penwidth.show()
self.ui.checkbox_fill.show()
self.ui.label_color.show()
self.ui.label_penwidth.show()
self.set_tool()
def set_line(self):
"""Activate the line button"""
self.unset_all()
self.ui.button_line.setChecked(True)
self.ui.edit_color.show()
self.ui.spin_penwidth.show()
self.ui.label_color.show()
self.ui.label_penwidth.show()
self.set_tool()
def set_arrow(self):
"""Activate the line button"""
self.unset_all()
self.ui.button_arrow.setChecked(True)
self.ui.edit_color.show()
self.ui.spin_penwidth.show()
self.ui.spin_arrow_size.show()
self.ui.label_color.show()
self.ui.label_penwidth.show()
self.ui.label_arrow_size.show()
self.set_tool()
def set_circle(self):
"""Activate the circle button"""
self.unset_all()
self.ui.button_circle.setChecked(True)
self.ui.edit_color.show()
self.ui.spin_penwidth.show()
self.ui.checkbox_fill.show()
self.ui.label_color.show()
self.ui.label_penwidth.show()
self.set_tool()
def set_fixdot(self):
"""Activate the fixdot button"""
self.unset_all()
self.ui.button_fixdot.setChecked(True)
self.ui.edit_color.show()
self.ui.label_color.show()
self.set_tool()
def set_image(self):
"""Activate the image button"""
self.unset_all()
self.ui.button_image.setChecked(True)
self.ui.spin_scale.show()
self.ui.checkbox_center.show()
self.ui.label_scale.show()
self.set_tool()
def set_textline(self):
"""Activate the textline button"""
self.unset_all()
self.ui.button_textline.setChecked(True)
self.ui.edit_color.show()
self.ui.checkbox_center.show()
self.ui.checkbox_html.show()
self.ui.label_color.show()
self.ui.widget_font.show()
self.set_tool()
def set_gabor(self):
"""Activate the textline button"""
self.unset_all()
self.ui.button_gabor.setChecked(True)
self.ui.label_options.show()
self.set_tool()
def set_noise(self):
"""Activate the textline button"""
self.unset_all()
self.ui.button_noise_patch.setChecked(True)
self.ui.label_options.show()
self.set_tool()
def add(self, from_pos, to_pos):
"""
Add an item to the sketchpad item list
Arguments:
from_pos -- an (x, y) tuple containing the top-left corner
to_pos -- an (x, y) tuple containing the bottom-right corner
"""
item = {}
item["type"] = self.tool
item["fill"] = self.fill
item["color"] = self.color
item["penwidth"] = self.penwidth
item["show_if"] = self.show_if
if self.tool in ("ellipse", "rect"):
if to_pos[0] > from_pos[0]:
item["x"] = from_pos[0]
item["w"] = to_pos[0] - from_pos[0]
else:
item["x"] = to_pos[0]
item["w"] = from_pos[0] - to_pos[0]
if to_pos[1] > from_pos[1]:
item["y"] = from_pos[1]
item["h"] = to_pos[1] - from_pos[1]
else:
item["y"] = to_pos[1]
item["h"] = from_pos[1] - to_pos[1]
elif self.tool in ("arrow", "line"):
item["x1"] = from_pos[0]
item["y1"] = from_pos[1]
item["x2"] = to_pos[0]
item["y2"] = to_pos[1]
item["arrow_size"] = self.arrow_size
elif self.tool == "fixdot":
item["x"] = to_pos[0]
item["y"] = to_pos[1]
elif self.tool == "circle":
item["x"] = from_pos[0]
item["y"] = from_pos[1]
item["r"] = 2 * math.sqrt( (from_pos[0] - to_pos[0]) ** 2 + (from_pos[1] - to_pos[1]) ** 2 )
elif self.tool == "textline":
text, ok = QtGui.QInputDialog.getText(self.ui.view, \
_("New textline"), _("Please enter a text for the textline"))
if not ok:
return
item["x"] = to_pos[0]
item["y"] = to_pos[1]
item["text"] = self.sketchpad.experiment.sanitize(text)
item["center"] = self.center
item["html"] = self.html
item["font_family"] = self.font_family
item["font_size"] = self.font_size
item["font_italic"] = self.sketchpad.experiment.auto_type( \
self.font_italic)
item["font_bold"] = self.sketchpad.experiment.auto_type( \
self.font_bold)
elif self.tool == "image":
path = pool_widget.select_from_pool(self.sketchpad.experiment.main_window)
if path == None or unicode(path) == "":
return
item["x"] = to_pos[0]
item["y"] = to_pos[1]
item["file"] = unicode(path)
item["scale"] = self.scale
item["center"] = self.center
elif self.tool == "gabor":
item["x"] = to_pos[0]
item["y"] = to_pos[1]
item = self.gabor_dialog(item)
if item == None:
return
elif self.tool == "noise":
item["x"] = to_pos[0]
item["y"] = to_pos[1]
item = self.noise_dialog(item)
if item == None:
return
item = self.sketchpad.unfix_coordinates(item)
self.sketchpad.items.append(item)
self.sketchpad.apply_edit_changes()
self.refresh()
def gabor_dialog(self, item):
"""
Presents the Gabor dialog and adds the relevant
parameters to an item
Arguments:
item -- the item to be filled in
Returns:
The passed item, but filled in with all the relevant parameters
"""
d = QtGui.QDialog(self)
d.ui = gabor_dialog_ui.Ui_gabor_dialog()
d.ui.setupUi(d)
self.sketchpad.experiment.main_window.theme.apply_theme(d)
resp = d.exec_()
if resp == QtGui.QDialog.Accepted:
env = ["gaussian", "linear", "circular", "rectangle"]
bgmode = ["avg", "col2"]
item["orient"] = d.ui.spin_orient.value()
item["size"] = d.ui.spin_size.value()
item["env"] = env[d.ui.combobox_env.currentIndex()]
item["stdev"] = d.ui.spin_stdev.value()
item["freq"] = d.ui.spin_freq.value()
item["phase"] = d.ui.spin_phase.value()
item["color1"] = unicode(d.ui.edit_color1.text())
item["color2"] = unicode(d.ui.edit_color2.text())
item["bgmode"] = bgmode[d.ui.combobox_bgmode.currentIndex()]
return item
return None
def noise_dialog(self, item):
"""
Presents the noise dialog and adds the relevant
parameters to an item
Arguments:
item -- the item to be filled in
Returns:
The passed item, but filled in with all the relevant parameters
"""
d = QtGui.QDialog(self)
d.ui = noise_patch_dialog_ui.Ui_noise_patch_dialog()
d.ui.setupUi(d)
self.sketchpad.experiment.main_window.theme.apply_theme(d)
resp = d.exec_()
if resp == QtGui.QDialog.Accepted:
env = ["gaussian", "linear", "circular", "rectangle"]
bgmode = ["avg", "col2"]
item["size"] = d.ui.spin_size.value()
item["env"] = env[d.ui.combobox_env.currentIndex()]
item["stdev"] = d.ui.spin_stdev.value()
item["color1"] = unicode(d.ui.edit_color1.text())
item["color2"] = unicode(d.ui.edit_color2.text())
item["bgmode"] = bgmode[d.ui.combobox_bgmode.currentIndex()]
return item
return None
def rect(self, x, y, w, h, pen, brush):
"""Draw rectangle"""
return self.scene.addRect(x, y, w, h, pen, brush)
def ellipse(self, x, y, w, h, pen, brush):
"""Draw ellipse"""
return self.scene.addEllipse(x, y, w, h, pen, brush)
def fixdot(self, x, y, color):
"""Draw fixation dot"""
color = QtGui.QColor(color)
pen = QtGui.QPen()
pen.setColor(color)
brush = QtGui.QBrush()
brush.setColor(color)
brush.setStyle(QtCore.Qt.SolidPattern)
r1 = 8
r2 = 2
i = self.scene.addEllipse(x - r1, y - r1, 2*r1, 2*r1, pen, brush)
brush.setColor(QtGui.QColor(self.sketchpad.get("background", \
_eval=False)))
self.scene.addEllipse(x - r2, y - r2, 2*r2, 2*r2, pen, brush)
return i
def arrow(self, sx, sy, ex, ey, arrow_size, pen):
"""Draw arrow"""
i = self.scene.addLine(sx, sy, ex, ey, pen)
a = math.atan2(ey - sy, ex - sx)
_sx = ex + arrow_size * math.cos(a + math.radians(135))
_sy = ey + arrow_size * math.sin(a + math.radians(135))
self.scene.addLine(_sx, _sy, ex, ey, pen)
_sx = ex + arrow_size * math.cos(a + math.radians(225))
_sy = ey + arrow_size * math.sin(a + math.radians(225))
self.scene.addLine(_sx, _sy, ex, ey, pen)
return i
def line(self, x1, y1, x2, y2, pen):
"""Draw line"""
return self.scene.addLine(x1, y1, x2, y2, pen)
def textline(self, text, center, x, y, color, font_family, font_size, \
font_bold, font_italic):
"""Draw textline"""
if font_family == "serif" and os.name == "nt":
font_family = "times" # WINDOWS HACK: Windows doesn't recognize serif
if font_bold:
weight = QtGui.QFont.Bold
else:
weight = QtGui.QFont.Normal
font = QtGui.QFont(font_family, font_size, weight, font_italic)
text_item = self.scene.addText(text, font)
text_item.setDefaultTextColor(QtGui.QColor(color))
if center:
r = text_item.boundingRect()
text_item.setPos(x - 0.5 * r.width(), y - 0.5 * r.height())
else:
text_item.setPos(x, y)
return text_item
def image(self, path, center, x, y, scale):
"""Draw image"""
pixmap = QtGui.QPixmap(path)
if pixmap.isNull():
# Qt4 cannot handle certain funky bitmaps that PyGame can. So if
# loading the image directly fails, we fall back to loading the
# image with PyGame and converting it to a QPixmap. In addition, we
# notify the user that he/ she is using a funky bitmap.
import pygame
im = pygame.image.load(path)
data = pygame.image.tostring(im, "RGBA")
size = im.get_size()
image = QtGui.QImage(data, size[0], size[1], \
QtGui.QImage.Format_ARGB32)
pixmap = QtGui.QPixmap.fromImage(image)
self.notifications.append( \
_("Funky image alert: '%s' has a non-standard format. It is recommended to convert this image to .png format, for example with Gimp .") \
% os.path.basename(path))
w = pixmap.width()*scale
pixmap = pixmap.scaledToWidth(w)
_item = self.scene.addPixmap(pixmap)
if center:
_item.setPos(x - 0.5 * pixmap.width(), y - 0.5 * pixmap.height())
else:
_item.setPos(x, y)
return _item
def gabor(self, item):
"""Draw gabor patch"""
path = openexp.canvas.gabor_file(item["orient"], item["freq"], \
item["env"], item["size"], item["stdev"], item["phase"], \
item["color1"], item["color2"], item["bgmode"])
pixmap = QtGui.QPixmap(path)
_item = self.scene.addPixmap(pixmap)
_item.setPos(item["x"]-0.5*pixmap.width(), \
item["y"]-0.5*pixmap.height())
return _item
def noise(self, item):
"""Draw noise patch"""
path = openexp.canvas.noise_file(item["env"], item["size"], \
item["stdev"], item["color1"], item["color2"], item["bgmode"])
pixmap = QtGui.QPixmap(path)
_item = self.scene.addPixmap(pixmap)
_item.setPos(item["x"]-0.5*pixmap.width(), \
item["y"]-0.5*pixmap.height())
return _item
def refresh(self):
"""(Re)draws the canvas and fill the item list."""
self.scene.clear()
self.ui.view.setMouseTracking(True)
w = self.sketchpad.get(u'width')
h = self.sketchpad.get(u'height')
# Apply the zoom level
self.ui.view.setFixedSize(self.zoom*w+60, self.zoom*h+60)
self.ui.view.resetTransform()
self.ui.view.scale(self.zoom, self.zoom)
# Set the foreground
self.ui.edit_color.initialize(self.sketchpad.experiment, color= \
self.color)
# Set the background
brush = QtGui.QBrush()
brush.setColor(QtGui.QColor(self.sketchpad.get(u'background', \
_eval=False)))
brush.setStyle(QtCore.Qt.SolidPattern)
self.ui.view.setBackgroundBrush(brush)
# Optionally draw a grid
if self.show_grid and self.zoom * self.scene.grid >= 5:
self.scene.draw_grid()
# Initialize the notifications
self.notifications = []
static_items = self.sketchpad.static_items()
not_shown = len(self.sketchpad.items) - len(static_items)
if not_shown > 1:
self.notifications.append( \
_(u"%d objects are not shown, because they are defined using variables.") \
% not_shown)
elif not_shown == 1:
self.notifications.append( \
_(u"One object is not shown, because it is defined using variables."))
if self.sketchpad.items_out_of_bounds() > 0:
self.notifications.append( \
_(u"Some objects will not be visible (or partly) because they fall outside of the screen boundaries."))
# Walk through all items and show them
self.item_list = []
for item in static_items:
g = None
try:
s = self.sketchpad.item_to_string(item)
item = self.sketchpad.fix_coordinates(item)
# Set the pen and the brush
pen = QtGui.QPen()
pen.setWidth(item["penwidth"])
pen.setColor(QtGui.QColor(item["color"]))
brush = QtGui.QBrush()
if item["fill"] == 1:
brush.setColor(QtGui.QColor(item["color"]))
brush.setStyle(QtCore.Qt.SolidPattern)
if item["type"] == "rect":
g = self.rect(item["x"], item["y"], item["w"], item["h"], \
pen, brush)
elif item["type"] == "circle":
g = self.ellipse(item["x"]-0.5*item["r"], \
item["y"]-0.5*item["r"], item["r"], item["r"], pen, \
brush)
elif item["type"] == "ellipse":
g = self.ellipse(item["x"], item["y"], item["w"], \
item["h"], pen, brush)
elif item["type"] == "fixdot":
g = self.fixdot(item["x"], item["y"], item["color"])
elif item["type"] == "arrow":
g = self.arrow(item["x1"], item["y1"], item["x2"], \
item["y2"], item["arrow_size"], pen)
elif item["type"] == "line":
g = self.line(item["x1"], item["y1"], item["x2"], \
item["y2"], pen)
elif item["type"] == "textline":
g = self.textline(item["text"], item["center"]==1, \
item["x"], item["y"], item["color"], \
item["font_family"], item["font_size"], \
item['font_bold'] == 'yes', item['font_italic'] == 'yes')
elif item["type"] == "image":
g = self.image(self.sketchpad.experiment.get_file( \
item["file"]), item["center"]==1, item["x"], \
item["y"], item["scale"])
elif item["type"] == "gabor":
g = self.gabor(item)
elif item["type"] == "noise":
g = self.noise(item)
else:
print "Could not find", item["type"]
except Exception as e:
debug.msg("exception caught: %s" % e)
self.notifications.append( \
_("Failed to parse the following item (use 'Edit script' to fix/ remove this line):\n'%s'") \
% s)
# Add a tooltip to the scene element
if g != None:
g.setToolTip(s)
self.item_list.append( (g, item) )
# Show the notifications (if any)
if len(self.notifications) > 0:
self.ui.frame_notification.setVisible(True)
self.ui.label_notification.setText("\n- ".join(["Notifications:"] + \
self.notifications))
else:
self.ui.frame_notification.setVisible(False)
# Add the items to the list below the sketchpad
self.sketchpad.experiment.clear_widget(self.ui.widget_items)
row = 0
for item in self.sketchpad.items:
edit = QtGui.QLineEdit(self.sketchpad.item_to_string(item))
edit.setReadOnly(True)
hbox = QtGui.QHBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(edit_item_button(self, item))
hbox.addWidget(edit)
hbox.addWidget(remove_item_button(self, item))
widget = QtGui.QWidget()
widget.setLayout(hbox)
self.vbox_items.addWidget(widget)
self.vbox_items.addStretch()
return True
def set_tool(self, dummy=None):
"""
Sets the current tool according to the options in the widget.
Keyword argument:
dummy -- DEPRECATED.
"""
self.penwidth = self.ui.spin_penwidth.value()
self.color = self.sketchpad.experiment.sanitize( \
self.ui.edit_color.text())
refs = []
try:
refs = self.sketchpad.experiment.get_refs(self.color)
self.sketchpad.experiment.color_check(self.color)
except Exception as e:
if len(refs) == 0:
self.sketchpad.experiment.notify(e)
self.ui.edit_color.setText(u'white')
self.color = u'white'
self.show_grid = self.ui.checkbox_show_grid.isChecked()
if self.ui.checkbox_fill.isChecked():
self.fill = 1
else:
self.fill = 0
if self.ui.checkbox_center.isChecked():
self.center = 1
else:
self.center = 0
self.arrow_size = self.ui.spin_arrow_size.value()
self.scale = self.ui.spin_scale.value() * 0.01
self.scene.grid = self.ui.spin_grid.value()
self.zoom = self.ui.spin_zoom.value() * 0.01
self.font_family = self.ui.widget_font.family
self.font_size = self.ui.widget_font.size
self.font_italic = self.ui.widget_font.italic
self.font_bold = self.ui.widget_font.bold
self.show_if = self.sketchpad.experiment.sanitize( \
self.ui.edit_show_if.text())
if self.ui.checkbox_html.isChecked():
self.html = u'yes'
else:
self.html = u'no'
if self.ui.button_line.isChecked():
self.tool = u'line'
self.scene.oneshot = False
elif self.ui.button_arrow.isChecked():
self.tool = u'arrow'
self.scene.oneshot = False
elif self.ui.button_rect.isChecked():
self.tool = u'rect'
self.scene.oneshot = False
elif self.ui.button_ellipse.isChecked():
self.tool = u'ellipse'
self.scene.oneshot = False
elif self.ui.button_circle.isChecked():
self.tool = u'circle'
self.scene.oneshot = False
elif self.ui.button_fixdot.isChecked():
self.tool = u'fixdot'
self.scene.oneshot = True
elif self.ui.button_image.isChecked():
self.tool = u'image'
self.scene.oneshot = True
elif self.ui.button_textline.isChecked():
self.tool = u'textline'
self.scene.oneshot = True
elif self.ui.button_gabor.isChecked():
self.tool = u'gabor'
self.scene.oneshot = True
elif self.ui.button_noise_patch.isChecked():
self.tool = u'noise'
self.scene.oneshot = True
self.refresh()
opensesame-0.27.4/libqtopensesame/widgets/pyterm_original.py 0000664 0001750 0001750 00000011700 12214350640 026626 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
import code
import sys
import os
import time
from PyQt4 import QtGui, QtCore
from libqtopensesame.misc import _
def modules():
"""Print version info"""
from libopensesame.misc import module_versions
print module_versions()
class output_buffer:
"""Used to capture the standard output and reroute it to the debug window"""
def __init__(self, plaintext):
"""
Constructor
Keyword arguments:
plaintext -- a QPlainTextEdit widget
"""
self.plaintext = plaintext
def readline(self):
"""Input is crudely supported through an input dialog"""
self.plaintext._input = ""
self.plaintext.collect_input = True
while len(self.plaintext._input) == 0 or self.plaintext._input[-1] != \
"\n":
time.sleep(0.01)
QtGui.QApplication.processEvents()
self.plaintext.collect_input = False
return self.plaintext._input
def write(self, s):
"""
Write a string
Arguments:
s -- a string
"""
if isinstance(s, str):
s = s.decode(u'utf-8', errors=u'replace')
if s.strip() != u'':
self.plaintext.appendPlainText(s)
QtGui.QApplication.processEvents()
def flush(self):
"""Dummy flush function for compatibility."""
pass
class pyterm(code.InteractiveConsole):
"""Custom Python interpreter"""
def __init__(self, textedit=None):
"""Constructor"""
global modules
self._locals = {"modules" : modules}
code.InteractiveConsole.__init__(self, self._locals)
self.textedit = textedit
def write(self, s):
"""
Simply redirect everything to the standard output.
Arguments:
s -- the output string
"""
if isinstance(s, str):
s = s.decode(u'utf-8', errors=u'replace')
print s.replace(u'\n', u'')
class console(QtGui.QPlainTextEdit):
"""A nice console widget"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- parent QWidget
"""
QtGui.QPlainTextEdit.__init__(self, parent)
if os.name == "posix":
font = QtGui.QFont("mono")
else:
font = QtGui.QFont("courier")
self.setFont(font)
self.collect_input = False
self._input = ""
self.history = []
self.prompt = ">>> "
self.pyterm = pyterm()
self.pyterm.textedit = self
self.setCursorWidth(8)
self.welcome()
self.show_prompt()
def clear(self):
"""Clear and draw prompt"""
QtGui.QPlainTextEdit.clear(self)
self.show_prompt()
def welcome(self):
"""Print welcome information"""
s = "Python %d.%d.%d" % (sys.version_info[0], sys.version_info[1], \
sys.version_info[2]) \
+ "\nType \"help()\", \"copyright()\", \"credits()\" or \"license()\" for more information." \
+ "\nType \"modules()\" for details about installed modules and version information." \
+ "\nUse the \"print [msg]\" statement in inline_script items to print to this debug window."
self.insertPlainText(s)
def show_prompt(self, suffix=""):
"""Show a prompt"""
self.appendPlainText(self.prompt+suffix)
def keyPressEvent(self, e):
"""
Handle key presses
Arguments:
e -- a QKeyEvent
"""
# Emulate the standard input
if self.collect_input:
if e.key() in [QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return]:
self._input += "\n"
else:
self._input += unicode(e.text())
QtGui.QPlainTextEdit.keyPressEvent(self, e)
# Emulate the console
else:
self.jump_to_end()
if e.key() == QtCore.Qt.Key_Up:
if len(self.history) > 0:
cmd = self.history.pop()
self.show_prompt(cmd)
elif e.key() in [QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return]:
self.execute()
elif e.key() not in [QtCore.Qt.Key_Left, QtCore.Qt.Key_Backspace]\
or self.textCursor().positionInBlock() > len(self.prompt):
QtGui.QPlainTextEdit.keyPressEvent(self, e)
def execute(self):
"""Execute a command"""
try:
s = unicode(self.document().lastBlock().text())[len(self.prompt):]
except:
self.appendPlainText( \
_("Error: Command contains invalid characters"))
self.show_prompt()
return
if len(s) > 0:
self.history.append(s)
buf = output_buffer(self)
sys.stdout = buf
sys.stdin = buf
self.pyterm.push(s)
sys.stdout = sys.__stdout__
sys.stdin = sys.__stdin__
self.show_prompt()
def jump_to_end(self):
"""Restore the cursor to the end of the textedit"""
c = self.textCursor()
if not c.atEnd() and c.blockNumber()+1 < self.document().blockCount():
c.movePosition(QtGui.QTextCursor.End)
self.setTextCursor(c)
opensesame-0.27.4/libqtopensesame/widgets/good_looking_table.py 0000664 0001750 0001750 00000013141 12173713501 027247 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
class good_looking_table(QtGui.QTableWidget):
"""Extended the QTableWidget for copy-pasting, etc."""
def __init__(self, rows, columns=None, icons={}, parent=None):
"""
Constructor.
Arguments:
rows -- The number of rows.
Keywords arguments:
columns -- The number of columns or None for no columns. (default=None)
icons -- A dictionary with QIcons for the various actions.
(default={})
parent -- The parent QWidget. (default=None)
"""
self.clipboard = QtGui.QApplication.clipboard
self.build_context_menu(icons)
# If there is only one parameter, this is the parent
if columns == None:
QtGui.QTableWidget.__init__(self, rows)
else:
QtGui.QTableWidget.__init__(self, rows, columns, parent)
self.setGridStyle(QtCore.Qt.DotLine)
self.setAlternatingRowColors(True)
def build_context_menu(self, icons={}):
"""
Builds the context menu.
Keyword arguments:
icons -- A dictionary with icon names. (default={})
"""
self.menu = QtGui.QMenu()
if "cut" in icons:
self.menu.addAction(icons["cut"], "Cut", self.cut)
else:
self.menu.addAction("Cut", self.cut)
if "copy" in icons:
self.menu.addAction(icons["copy"], "Copy", self.copy)
else:
self.menu.addAction("Copy", self.copy)
if "paste" in icons:
self.menu.addAction(icons["paste"], "Paste", self.paste)
else:
self.menu.addAction("Paste", self.paste)
if "clear" in icons:
self.menu.addAction(icons["clear"], "Clear", self._clear)
else:
self.menu.addAction("Clear", self._clear)
def contextMenuEvent(self, e):
"""
Presents the context menu.
Arguments:
e -- a QContextMenuEvent.
"""
self.pos = e.globalPos()
self.menu.exec_(self.pos)
def keyPressEvent(self, e):
"""
Captures keypresses to handle copy, cut, and paste.
Arguments:
e -- a QKeyEvent.
"""
if e.key() == QtCore.Qt.Key_Delete:
self._clear()
e.ignore()
elif e.modifiers() == QtCore.Qt.ControlModifier and e.key() == \
QtCore.Qt.Key_X:
self.cut()
e.ignore()
elif e.modifiers() == QtCore.Qt.ControlModifier and e.key() == \
QtCore.Qt.Key_C:
self.copy()
e.ignore()
elif e.modifiers() == QtCore.Qt.ControlModifier and e.key() == \
QtCore.Qt.Key_V:
self.paste()
e.ignore()
else:
QtGui.QTableWidget.keyPressEvent(self, e)
def cut(self):
"""Cuts text from the table into the clipboard (copy + clear = cut)"""
self.copy()
self._clear()
def copy(self):
"""Copies data from the table into the clipboard."""
_range = self.selectedRanges()[0]
rows = []
for row in range(_range.topRow(), _range.bottomRow()+1):
columns = []
for column in range(_range.leftColumn(), _range.rightColumn()+1):
item = self.item(row, column)
if item != None:
value = unicode(item.text())
else:
value = u''
columns.append(value)
rows.append(u'\t'.join(columns))
selection = u'\n'.join(rows)
self.clipboard().setText(selection)
def paste(self):
"""Pastes text from the clipboard into the table."""
selection = unicode(self.clipboard().mimeData().text())
rows = selection.split(u'\n')
current_row = self.currentRow()
for row in rows:
cells = row.split(u'\t')
current_column = self.currentColumn()
for cell in cells:
if current_column >= self.columnCount():
break
item = QtGui.QTableWidgetItem()
item.setText(cell)
self.setItem(current_row, current_column, item)
current_column += 1
current_row += 1
def _clear(self):
"""Clears the selected cells."""
selected_range = self.selectedRanges()[0]
for row in range(selected_range.topRow(), selected_range.bottomRow() + \
1):
for column in range(selected_range.leftColumn(), \
selected_range.rightColumn() + 1):
item = self.item(row, column)
if item != None:
item.setText(u'')
def get_contents(self):
"""
Gets the contents of the table.
Returns:
A QStringList for the table contents.
"""
contents = QtCore.QStringList()
for row in range(self.rowCount()):
for column in range(self.columnCount()):
i = self.item(row, column)
if i != None:
contents.append(i.text())
else:
contents.append(QtCore.QString())
return contents
def set_contents(self, contents):
"""
Sets the table contents.
Arguments:
contents -- a QStringList.
"""
column = 0
row = 0
for i in contents:
# Set the item
item = QtGui.QTableWidgetItem()
item.setText(i)
self.setItem(row, column, item)
# Advance to next cell with wraparound
column += 1
if column == self.columnCount():
row += 1
column = 0
if __name__ == "__main__":
"""If called standalone, this class shows a demo table"""
import sys
app = QtGui.QApplication(sys.argv)
widget = good_looking_table(10, 10)
widget.setWindowTitle("Good looking table")
widget.show()
app.exec_()
print widget.get_contents()
opensesame-0.27.4/libqtopensesame/widgets/user_hint_widget.py 0000664 0001750 0001750 00000003406 12143215416 026773 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from libqtopensesame.ui import user_hint_widget_ui
from PyQt4 import QtGui
class user_hint_widget(QtGui.QFrame):
"""Provides various informative hints to the user"""
def __init__(self, parent, item):
"""
Constructor.
Arguments:
parent -- The parent QWidget.
item -- The item to provide a header for.
"""
QtGui.QWidget.__init__(self)
self.main_window = parent
self.item = item
self.ui = user_hint_widget_ui.Ui_user_hint_widget()
self.ui.setupUi(self)
self.ui.button_edit_script.clicked.connect(self.item.open_script_tab)
self.main_window.theme.apply_theme(self)
self.hide()
def add_user_hint(self, hint):
"""
Adds a user hint.
Arguments:
hint -- A text with the user hint.
"""
self.hints.append(hint)
def clear(self):
"""Clears all user hints."""
self.hints = []
self.hide()
def refresh(self):
"""Updates the widget with the current user hints."""
if len(self.hints) == 0:
self.hide()
return
s = '\n'.join(self.hints)
self.ui.label_user_hint.setText(s)
self.show() opensesame-0.27.4/libqtopensesame/widgets/pyterm.py 0000664 0001750 0001750 00000001465 12061663322 024755 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
import sys
if "--ipython" in sys.argv:
from pyterm_ipython import console, output_buffer
else:
from pyterm_original import console, output_buffer
opensesame-0.27.4/libqtopensesame/widgets/general_properties.py 0000664 0001750 0001750 00000025010 12173713501 027315 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from libopensesame import debug
from PyQt4 import QtCore, QtGui
from libopensesame import misc
from libqtopensesame.misc import _
import libopensesame.exceptions
from libqtopensesame.ui import general_widget_ui
from libqtopensesame.widgets import color_edit, inline_editor, header_widget
from libqtopensesame.items import experiment
from libqtopensesame.misc import config
import openexp.backend_info
import sip
class general_properties(QtGui.QWidget):
"""The QWidget for the general properties tab."""
backend_format = u'%s [%s]'
def __init__(self, parent=None):
"""
Constructor.
Keywords arguments:
parent -- The parent QWidget. (default=None)
"""
self.main_window = parent
QtGui.QWidget.__init__(self)
# Set the header, with the icon, label and script button
self.header_widget = general_header_widget(self, \
self.main_window.experiment)
button_help = QtGui.QPushButton(self.main_window.experiment.icon( \
"help"), "")
button_help.setIconSize(QtCore.QSize(16, 16))
button_help.clicked.connect( \
self.main_window.ui.tabwidget.open_general_help)
button_help.setToolTip(_("Tell me more about OpenSesame!"))
header_hbox = QtGui.QHBoxLayout()
header_hbox.addWidget(self.main_window.experiment.label_image( \
"experiment"))
header_hbox.addWidget(self.header_widget)
header_hbox.addStretch()
header_hbox.addWidget(button_help)
header_hbox.setContentsMargins(0, 0, 0, 0)
header_widget = QtGui.QWidget()
header_widget.setLayout(header_hbox)
# The rest of the controls from the UI file
w = QtGui.QWidget()
self.ui = general_widget_ui.Ui_general_widget()
self.ui.setupUi(w)
self.main_window.theme.apply_theme(self)
# Initialize the color and font widgets
self.ui.edit_foreground.initialize(self.main_window.experiment)
self.ui.edit_background.initialize(self.main_window.experiment)
QtCore.QObject.connect(self.ui.edit_foreground, QtCore.SIGNAL( \
"set_color"), self.apply_changes)
QtCore.QObject.connect(self.ui.edit_background, QtCore.SIGNAL( \
"set_color"), self.apply_changes)
self.ui.widget_font.initialize(self.main_window.experiment)
QtCore.QObject.connect(self.ui.widget_font, QtCore.SIGNAL( \
"font_changed"), self.apply_changes)
# Connect the rest
self.ui.spinbox_width.editingFinished.connect(self.apply_changes)
self.ui.spinbox_height.editingFinished.connect(self.apply_changes)
self.ui.button_script_editor.clicked.connect( \
self.main_window.ui.tabwidget.open_general_script)
self.ui.button_backend_settings.clicked.connect( \
self.main_window.ui.tabwidget.open_backend_settings)
# Set the backend combobox
for backend in openexp.backend_info.backend_list:
desc = openexp.backend_info.backend_list[backend]["description"]
icon = openexp.backend_info.backend_list[backend]["icon"]
self.ui.combobox_backend.addItem(self.main_window.theme.qicon( \
icon), self.backend_format % (backend, desc))
self.ui.combobox_backend.currentIndexChanged.connect(self.apply_changes)
# Variable transparency
self.ui.checkbox_transparent_variables.stateChanged.connect( \
self.apply_changes)
vbox = QtGui.QVBoxLayout()
vbox.addWidget(header_widget)
vbox.addWidget(w)
self.setLayout(vbox)
self.tab_name = '__general_properties__'
self.on_activate = self.refresh
def set_header_label(self):
"""
Sets the general header based on the experiment title and description.
"""
self.header_widget.edit_name.setText(self.main_window.experiment.title)
self.header_widget.label_name.setText( \
u"%s - Experiment Click to edit" \
% self.main_window.experiment.title)
self.header_widget.edit_desc.setText( \
self.main_window.experiment.description)
self.header_widget.label_desc.setText(\
self.main_window.experiment.description)
def apply_changes(self):
"""Applies changes to the general tab."""
# Skip if the general tab is locked and lock it otherwise
if self.lock:
return
self.lock = True
debug.msg()
rebuild_item_tree = False
self.main_window.set_busy(True)
# Set the title and the description
title = self.main_window.experiment.sanitize( \
self.header_widget.edit_name.text())
self.main_window.experiment.set(u"title", title)
desc = self.main_window.experiment.sanitize( \
self.header_widget.edit_desc.text())
self.main_window.experiment.set(u"description", desc)
# Set the backend
if self.ui.combobox_backend.isEnabled():
i = self.ui.combobox_backend.currentIndex()
backend = openexp.backend_info.backend_list.values()[i]
self.main_window.experiment.set(u"canvas_backend", \
backend[u"canvas"])
self.main_window.experiment.set(u"keyboard_backend", \
backend[u"keyboard"])
self.main_window.experiment.set(u"mouse_backend", \
backend[u"mouse"])
self.main_window.experiment.set(u"sampler_backend", \
backend[u"sampler"])
self.main_window.experiment.set(u"synth_backend", \
backend[u"synth"])
else:
debug.msg( \
u'not setting back-end, because a custom backend is selected')
# Set the display width
width = self.ui.spinbox_width.value()
if self.main_window.experiment.get(u"width") != width:
self.main_window.update_resolution(width, \
self.main_window.experiment.get(u"height"))
# Set the display height
height = self.ui.spinbox_height.value()
if self.main_window.experiment.get(u"height") != height:
self.main_window.update_resolution( \
self.main_window.experiment.get(u"width"), height)
# Set the foreground color
foreground = self.main_window.experiment.sanitize( \
self.ui.edit_foreground.text())
refs = []
try:
refs = self.main_window.experiment.get_refs(foreground)
self.main_window.experiment.color_check(foreground)
except Exception as e:
if refs == []:
self.main_window.experiment.notify(e)
foreground = self.main_window.experiment.get(u"foreground")
self.ui.edit_foreground.setText(foreground)
self.main_window.experiment.set(u"foreground", foreground)
# Set the background color
background = self.main_window.experiment.sanitize( \
self.ui.edit_background.text())
refs = []
try:
refs = self.main_window.experiment.get_refs(background)
self.main_window.experiment.color_check(background)
except Exception as e:
if refs == []:
self.main_window.experiment.notify(e)
background = self.main_window.experiment.get(u"background")
self.ui.edit_background.setText(background)
self.main_window.experiment.set(u"background", foreground)
self.main_window.experiment.set(u"background", background)
# Set the font
self.main_window.experiment.set(u'font_family', \
self.ui.widget_font.family)
self.main_window.experiment.set(u'font_size', \
self.ui.widget_font.size)
self.main_window.experiment.set(u'font_italic', \
self.ui.widget_font.italic)
self.main_window.experiment.set(u'font_bold', \
self.ui.widget_font.bold)
# Set variable transparency
self.main_window.experiment.set(u'transparent_variables', \
self.ui.checkbox_transparent_variables.isChecked())
# Refresh the interface and unlock the general tab
self.main_window.refresh()
self.lock = False
self.main_window.set_busy(False)
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
class general_header_widget(header_widget.header_widget):
"""
The widget containing the clickable title and description of the experiment
"""
def __init__(self, general_tab, item):
"""
Constructor
Arguments:
item -- the experiment
"""
header_widget.header_widget.__init__(self, item)
self.general_tab = general_tab
self.label_name.setText( \
u"%s - Experiment Click to edit" \
% self.item.get(u"title", _eval=False))
def restore_name(self):
"""Apply the name change, hide the editable title and show the label"""
self.general_tab.apply_changes()
self.label_name.setText( \
u"%s - Experiment Click to edit" \
% self.item.get(u"title", _eval=False))
self.label_name.show()
self.edit_name.setText(self.item.get(u"title", _eval=False))
self.edit_name.hide()
def restore_desc(self):
"""
Apply the description change, hide the editable description and show the label
"""
self.general_tab.apply_changes()
self.label_desc.setText(self.item.get(u"description", _eval=False))
self.label_desc.show()
self.edit_desc.setText(self.item.get(u"description", _eval=False))
self.edit_desc.hide()
opensesame-0.27.4/libqtopensesame/widgets/unused_widget.py 0000664 0001750 0001750 00000005740 12173713501 026302 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from libopensesame import debug
from libqtopensesame.misc import config, _
from PyQt4 import QtGui, QtCore
class unused_widget(QtGui.QWidget):
"""The unused items widget"""
def __init__(self, parent=None):
"""
Constructor.
Keywords arguments:
parent -- The parent QWidget. (default=None)
"""
self.main_window = parent
self.experiment = self.main_window.experiment
QtGui.QWidget.__init__(self, parent)
# Set the header, with the icon, label and script button
header_hbox = QtGui.QHBoxLayout()
header_hbox.addWidget(self.experiment.label_image(u"unused"))
header_label = QtGui.QLabel()
header_label.setText(_(u"Unused"))
header_hbox.addWidget(header_label)
header_hbox.addStretch()
header_widget = QtGui.QWidget()
header_widget.setLayout(header_hbox)
purge_button = QtGui.QPushButton(self.experiment.icon(u"purge"), \
_(u"Permanently delete unused items"))
purge_button.setIconSize(QtCore.QSize(16, 16))
QtCore.QObject.connect(purge_button, QtCore.SIGNAL(u"clicked()"), \
self.purge_unused)
purge_hbox = QtGui.QHBoxLayout()
purge_hbox.addWidget(purge_button)
purge_hbox.addStretch()
purge_widget = QtGui.QWidget()
purge_widget.setLayout(purge_hbox)
vbox = QtGui.QVBoxLayout()
vbox.addWidget(header_widget)
vbox.addWidget(purge_widget)
vbox.addStretch()
self.setLayout(vbox)
self.__unused_tab__ = True
def purge_unused(self):
"""Remove all unused items from the items list"""
# Ask confirmation
resp = QtGui.QMessageBox.question(self.main_window.ui.centralwidget, \
_(u"Permanently delete items?"), \
_(u"Are you sure you want to permanently delete all unused items? This action cannot be undone."), \
QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if resp == QtGui.QMessageBox.No:
return
# We need a loop, because items may become unused
# by deletion of their unused parent items
while len(self.main_window.experiment.unused_items) > 0:
for item in self.main_window.experiment.unused_items:
if item in self.main_window.experiment.items:
del self.main_window.experiment.items[item]
self.main_window.experiment.build_item_tree()
# Notify dispatch
self.main_window.dispatch.event_structure_change.emit(u'')
self.main_window.ui.tabwidget.close_all()
self.main_window.ui.tabwidget.open_general() opensesame-0.27.4/libqtopensesame/widgets/preferences_widget.py 0000664 0001750 0001750 00000026671 12173713304 027307 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from libopensesame import debug
from libqtopensesame.ui import preferences_widget_ui
from libqtopensesame.misc import config, theme
from libopensesame import plugins
from PyQt4 import QtCore, QtGui
import os
class preferences_widget(QtGui.QWidget):
"""The widget displayed in the preferences tab"""
def __init__(self, parent):
"""
Constructor
Arguments:
parent -- the parent widget
"""
QtGui.QWidget.__init__(self, parent)
self.tab_name = "__preferences__"
self.main_window = parent
# Setup the GUI
self.ui = preferences_widget_ui.Ui_preferences_widget()
self.ui.setupUi(self)
self.main_window.theme.apply_theme(self)
self.lock = False
# Connect the controls
self.ui.checkbox_immediately_rename.toggled.connect(self.apply)
self.ui.checkbox_autoresponse.toggled.connect(self.apply)
self.ui.checkbox_toolbar_text.toggled.connect(self.apply)
self.ui.checkbox_small_toolbar.toggled.connect(self.apply)
self.ui.checkbox_enable_autosave.toggled.connect(self.apply)
self.ui.spinbox_autosave_interval.valueChanged.connect(self.apply)
self.ui.spinbox_autosave_max_age.valueChanged.connect(self.apply)
self.ui.checkbox_auto_update_check.toggled.connect(self.apply)
self.ui.checkbox_opensesamerun.toggled.connect(self.apply)
self.ui.checkbox_auto_opensesamerun_exec.toggled.connect(self.apply)
self.ui.edit_opensesamerun_exec.editingFinished.connect(self.apply)
self.ui.button_browse_autosave.clicked.connect( \
self.main_window.open_autosave_folder)
self.ui.button_update_check.clicked.connect( \
self.main_window.check_update)
self.ui.combobox_style.currentIndexChanged.connect(self.apply)
self.ui.combobox_theme.currentIndexChanged.connect(self.apply)
self.ui.checkbox_scintilla_auto_indent.toggled.connect(self.apply)
self.ui.checkbox_scintilla_brace_match.toggled.connect(self.apply)
self.ui.checkbox_scintilla_custom_font.toggled.connect(self.apply)
self.ui.checkbox_scintilla_eol_visible.toggled.connect(self.apply)
self.ui.checkbox_scintilla_folding.toggled.connect(self.apply)
self.ui.checkbox_scintilla_indentation_guides.toggled.connect( \
self.apply)
self.ui.checkbox_scintilla_line_numbers.toggled.connect(self.apply)
self.ui.checkbox_scintilla_right_margin.toggled.connect(self.apply)
self.ui.checkbox_scintilla_syntax_highlighting.toggled.connect( \
self.apply)
self.ui.checkbox_scintilla_whitespace_visible.toggled.connect(self.apply)
self.ui.font_scintilla_font_family.currentFontChanged.connect(self.apply)
self.ui.spinbox_scintilla_font_size.valueChanged.connect(self.apply)
# Construct the plugin section
self.checkbox_plugins = {}
self.ui.edit_plugin_folders.setText("; ".join(plugins.plugin_folders( \
only_existing=False)))
for plugin in sorted(plugins.list_plugins(filter_disabled=False)):
self.checkbox_plugins[plugin] = QtGui.QCheckBox(plugin)
self.checkbox_plugins[plugin].toggled.connect(self.apply)
self.ui.layout_plugin_list.addWidget(self.checkbox_plugins[plugin])
self.set_controls()
def set_controls(self):
"""Update the controls"""
if self.lock:
return
self.lock = True
debug.msg()
self.ui.checkbox_immediately_rename.setChecked( \
config.get_config('immediate_rename'))
self.ui.checkbox_autoresponse.setChecked( \
self.main_window.experiment.auto_response)
self.ui.checkbox_toolbar_text.setChecked( \
self.main_window.ui.toolbar_main.toolButtonStyle() == \
QtCore.Qt.ToolButtonTextUnderIcon)
self.ui.checkbox_small_toolbar.setChecked( \
config.get_config("toolbar_size") == 16)
self.ui.checkbox_enable_autosave.setChecked( \
config.get_config('autosave_interval') > 0)
self.ui.spinbox_autosave_interval.setValue( \
config.get_config('autosave_interval') / 60000) # Show in minutes
self.ui.spinbox_autosave_max_age.setValue( \
config.get_config('autosave_max_age'))
self.ui.checkbox_auto_update_check.setChecked(config.get_config( \
'auto_update_check'))
self.ui.checkbox_opensesamerun.setChecked( \
config.get_config('opensesamerun'))
self.ui.checkbox_auto_opensesamerun_exec.setChecked( \
config.get_config('opensesamerun_exec') == '')
self.ui.edit_opensesamerun_exec.setText( \
config.get_config('opensesamerun_exec'))
self.ui.checkbox_scintilla_auto_indent.setChecked(config.get_config( \
"scintilla_auto_indent"))
self.ui.checkbox_scintilla_brace_match.setChecked(config.get_config( \
"scintilla_brace_match"))
self.ui.checkbox_scintilla_custom_font.setChecked(config.get_config( \
"scintilla_custom_font"))
self.ui.checkbox_scintilla_eol_visible.setChecked(config.get_config( \
"scintilla_eol_visible"))
self.ui.checkbox_scintilla_folding.setChecked(config.get_config( \
"scintilla_folding"))
self.ui.checkbox_scintilla_indentation_guides.setChecked( \
config.get_config("scintilla_indentation_guides"))
self.ui.checkbox_scintilla_line_numbers.setChecked(config.get_config( \
"scintilla_line_numbers"))
self.ui.checkbox_scintilla_right_margin.setChecked(config.get_config( \
"scintilla_right_margin"))
self.ui.checkbox_scintilla_auto_indent.setChecked(config.get_config( \
"scintilla_auto_indent"))
self.ui.checkbox_scintilla_syntax_highlighting.setChecked( \
config.get_config("scintilla_syntax_highlighting"))
self.ui.checkbox_scintilla_whitespace_visible.setChecked( \
config.get_config("scintilla_whitespace_visible"))
self.ui.font_scintilla_font_family.setCurrentFont(QtGui.QFont( \
config.get_config("scintilla_font_family")))
self.ui.spinbox_scintilla_font_size.setValue(config.get_config( \
"scintilla_font_size"))
# Disable some of the controls, if they depend on other controls
if config.get_config('autosave_interval') <= 0:
self.ui.spinbox_autosave_interval.setDisabled(True)
if not config.get_config('opensesamerun'):
self.ui.checkbox_auto_opensesamerun_exec.setDisabled(True)
self.ui.edit_opensesamerun_exec.setDisabled(True)
self.ui.label_opensesamerun_exec.setDisabled(True)
if config.get_config('opensesamerun_exec') == '':
self.ui.edit_opensesamerun_exec.setDisabled(True)
self.ui.label_opensesamerun_exec.setDisabled(True)
# Set the style combobox
i = 0
if config.get_config('style') == '':
self.ui.combobox_style.addItem("[Default]")
self.ui.combobox_style.setCurrentIndex(i)
i += 1
for style in QtGui.QStyleFactory.keys():
self.ui.combobox_style.addItem(style)
if config.get_config('style') == unicode(style):
self.ui.combobox_style.setCurrentIndex(i)
i += 1
# Set the theme combobox
i = 0
for _theme in theme.available_themes:
self.ui.combobox_theme.addItem(_theme)
if config.get_config('theme') == _theme:
self.ui.combobox_theme.setCurrentIndex(i)
i += 1
# Set the plugin status
for plugin in plugins.list_plugins(filter_disabled=False):
self.checkbox_plugins[plugin].setChecked(not \
plugins.plugin_disabled(plugin))
self.lock = False
def apply(self):
"""Apply the controls"""
if self.lock:
return
self.lock = True
debug.msg()
config.set_config('immediate_rename', \
self.ui.checkbox_immediately_rename.isChecked())
self.main_window.experiment.auto_response = \
self.ui.checkbox_autoresponse.isChecked()
self.main_window.ui.action_enable_auto_response.setChecked( \
self.ui.checkbox_autoresponse.isChecked())
if self.ui.checkbox_toolbar_text.isChecked():
self.main_window.ui.toolbar_main.setToolButtonStyle( \
QtCore.Qt.ToolButtonTextUnderIcon)
else:
self.main_window.ui.toolbar_main.setToolButtonStyle( \
QtCore.Qt.ToolButtonIconOnly)
old_size = config.get_config('toolbar_size')
if self.ui.checkbox_small_toolbar.isChecked():
new_size = 16
else:
new_size = 32
if old_size != new_size:
config.set_config("toolbar_size", new_size)
self.main_window.theme.set_toolbar_size(config.get_config( \
"toolbar_size"))
if self.ui.checkbox_enable_autosave.isChecked():
config.set_config('autosave_interval', 60000 * \
self.ui.spinbox_autosave_interval.value())
else:
config.set_config('autosave_interval', 0)
config.set_config('autosave_max_age', \
self.ui.spinbox_autosave_max_age.value())
self.main_window.start_autosave_timer()
config.set_config('auto_update_check', \
self.ui.checkbox_auto_update_check.isChecked())
config.set_config('opensesamerun', \
self.ui.checkbox_opensesamerun.isChecked())
self.ui.edit_opensesamerun_exec.setEnabled( \
self.ui.checkbox_opensesamerun.isChecked() and not \
self.ui.checkbox_auto_opensesamerun_exec.isChecked())
self.ui.label_opensesamerun_exec.setEnabled( \
self.ui.checkbox_opensesamerun.isChecked() and not \
self.ui.checkbox_auto_opensesamerun_exec.isChecked())
if self.ui.checkbox_auto_opensesamerun_exec.isChecked():
config.set_config('opensesamerun_exec', '')
self.ui.edit_opensesamerun_exec.setText('')
else:
if self.ui.edit_opensesamerun_exec.text() == "":
if os.name == "nt":
self.ui.edit_opensesamerun_exec.setText( \
"opensesamerun.exe")
else:
self.ui.edit_opensesamerun_exec.setText("opensesamerun")
config.set_config('opensesamerun_exec', unicode( \
self.ui.edit_opensesamerun_exec.text()))
config.set_config("scintilla_auto_indent", \
self.ui.checkbox_scintilla_auto_indent.isChecked())
config.set_config("scintilla_brace_match", \
self.ui.checkbox_scintilla_brace_match.isChecked())
config.set_config("scintilla_custom_font", \
self.ui.checkbox_scintilla_custom_font.isChecked())
config.set_config("scintilla_eol_visible", \
self.ui.checkbox_scintilla_eol_visible.isChecked())
config.set_config("scintilla_folding", \
self.ui.checkbox_scintilla_folding.isChecked())
config.set_config("scintilla_indentation_guides", \
self.ui.checkbox_scintilla_indentation_guides.isChecked())
config.set_config("scintilla_line_numbers", \
self.ui.checkbox_scintilla_line_numbers.isChecked())
config.set_config("scintilla_right_margin", \
self.ui.checkbox_scintilla_right_margin.isChecked())
config.set_config("scintilla_syntax_highlighting", \
self.ui.checkbox_scintilla_syntax_highlighting.isChecked())
config.set_config("scintilla_whitespace_visible", \
self.ui.checkbox_scintilla_whitespace_visible.isChecked())
config.set_config("scintilla_font_family", unicode( \
self.ui.font_scintilla_font_family.currentFont().family()))
config.set_config("scintilla_font_size", \
self.ui.spinbox_scintilla_font_size.value())
config.set_config('theme', unicode(self.ui.combobox_theme.currentText()))
# Create a semicolon-separated list of disabled plugins
l = []
for plugin in plugins.list_plugins(filter_disabled=False):
if not self.checkbox_plugins[plugin].isChecked():
l.append(plugin)
config.set_config("disabled_plugins", ";".join(l))
config.set_config('style', unicode(self.ui.combobox_style.currentText()))
self.main_window.save_state()
self.lock = False
opensesame-0.27.4/libqtopensesame/__init__.py 0000664 0001750 0001750 00000002216 12173713501 023520 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from PyQt4 import QtCore
if QtCore.QCoreApplication != None:
# Redirect certain things so that the old way of from libqtopensesame import
# qtplugin still works.
from libqtopensesame.items import qtplugin
from libqtopensesame.widgets import inline_editor, pool_widget
else:
# Load dummy modules to avoid dependency on PyQt4
from libqtopensesame.misc import dummy as qtplugin
from libqtopensesame.misc import dummy as qtautoplugin
opensesame-0.27.4/libqtopensesame/qtopensesamerun.py 0000664 0001750 0001750 00000006176 12061663322 025224 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.ui import opensesamerun_ui
from libqtopensesame.misc import theme
class qtopensesamerun(QtGui.QMainWindow):
"""
The main class of the OpenSesame Run GUI.
"""
def __init__(self, options, parent = None):
"""
Constructor
"""
# Construct the parent
QtGui.QMainWindow.__init__(self, parent)
# Setup the UI
self.ui = opensesamerun_ui.Ui_opensesamerun_mainwindow()
self.ui.setupUi(self)
self.ui.button_run.clicked.connect(self.run)
self.theme = theme.theme(self)
self.ui.button_browse_experiment.clicked.connect(self.browse_experiment)
self.ui.button_browse_logfile.clicked.connect(self.browse_logfile)
self.options = options
# Fill the GUI controls based on the options
self.ui.edit_experiment.setText(self.options.experiment)
self.ui.checkbox_fullscreen.setChecked(self.options.fullscreen)
self.ui.checkbox_pylink.setChecked(self.options.pylink)
self.ui.spinbox_subject_nr.setValue(int(self.options.subject))
self.ui.edit_logfile.setText(self.options.logfile)
def browse_experiment(self):
"""
Locate the experiment file
"""
file_type_filter = "OpenSesame files (*.opensesame.tar.gz *.opensesame);;OpenSesame script and file pool (*.opensesame.tar.gz);;OpenSesame script (*.opensesame)"
path = QtGui.QFileDialog.getOpenFileName(self, "Open experiment file", filter = file_type_filter)
if path == "":
return
self.ui.edit_experiment.setText(path)
def browse_logfile(self):
"""
Locate the logfile
"""
path = QtGui.QFileDialog.getSaveFileName(self, "Choose a location for the logfile")
if path == "":
return
self.ui.edit_logfile.setText(path)
def show(self):
"""
Set the run flag to false
"""
self.run = False
QtGui.QMainWindow.show(self)
def run(self):
"""
Does not actual run the experiment, but marks the application for
running later
"""
self.run = True
self.options.experiment = unicode(self.ui.edit_experiment.text())
self.options.subject = self.ui.spinbox_subject_nr.value()
self.options.logfile = unicode(self.ui.edit_logfile.text())
self.options.fullscreen = self.ui.checkbox_fullscreen.isChecked()
self.options.custom_resolution = self.ui.checkbox_custom_resolution.isChecked()
self.options.width = self.ui.spinbox_width.value()
self.options.height = self.ui.spinbox_height.value()
self.options.pylink = self.ui.checkbox_pylink.isChecked()
self.close()
opensesame-0.27.4/libqtopensesame/dialogs/ 0000775 0001750 0001750 00000000000 12214554461 023034 5 ustar sebastiaan sebastiaan 0000000 0000000 opensesame-0.27.4/libqtopensesame/dialogs/sketchpad_dialog.py 0000664 0001750 0001750 00000003552 12061663322 026675 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.widgets import sketchpad_widget
class sketchpad_dialog(QtGui.QDialog):
"""This dialog is the pop-out version of the sketchpad_widget"""
def __init__(self, parent, sketchpad):
"""
Constructor
Arguments:
parent -- parent QWidget
Keyword arguments:
sketchpad -- sketchpad item
"""
QtGui.QDialog.__init__(self, parent, \
QtCore.Qt.WindowMinMaxButtonsHint | QtCore.Qt.WindowCloseButtonHint)
self.sketchpad = sketchpad
self.tools_widget = sketchpad_widget.sketchpad_widget(self.sketchpad, \
parent=self, embed=False)
self.close_button = QtGui.QPushButton( \
self.sketchpad.experiment.icon("close"), "Close")
self.close_button.setIconSize(QtCore.QSize(16,16))
QtCore.QObject.connect(self.close_button, QtCore.SIGNAL("clicked()"), \
self.accept)
self.hbox = QtGui.QHBoxLayout()
self.hbox.addStretch()
self.hbox.addWidget(self.close_button)
self.hbox.setContentsMargins(0, 0, 0, 0)
self.hbox_widget = QtGui.QWidget()
self.hbox_widget.setLayout(self.hbox)
self.vbox = QtGui.QVBoxLayout()
self.vbox.addWidget(self.tools_widget)
self.vbox.addWidget(self.hbox_widget)
self.setLayout(self.vbox)
opensesame-0.27.4/libqtopensesame/dialogs/replace_dialog.py 0000664 0001750 0001750 00000004335 12061663322 026342 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtGui, QtCore
from libqtopensesame.ui import replace_dialog_ui
from libqtopensesame.misc import config, _
class replace_dialog(QtGui.QDialog):
"""A search/ replace dialog"""
def __init__(self, parent=None):
"""
Constructor
Keywords arguments:
parent -- the parent QWidget
"""
QtGui.QDialog.__init__(self, parent)
self.edit = parent.edit
self.ui = replace_dialog_ui.Ui_replace_dialog()
self.ui.setupUi(self)
parent.experiment.main_window.theme.apply_theme(self)
self.adjustSize()
self.ui.edit_search.setText(parent.search.text())
self.ui.button_search.clicked.connect(self.search)
self.ui.button_replace.clicked.connect(self.replace)
self.ui.button_replace_all.clicked.connect(self.replace_all)
def search(self):
"""
Select text matching the search term
Returns:
True if the string was found, False otherwise
"""
return self.parent().perform_search(term=self.ui.edit_search.text())
def replace(self):
"""Replace the current selection with the replace term"""
self.parent().edit.replace(self.ui.edit_replace.text())
def replace_all(self):
"""
Iteratively replace all occurences of the search term with the
replace term
"""
if self.ui.edit_search.text().toLower() in \
self.ui.edit_replace.text().toLower():
QtGui.QMessageBox.information(self, _("Oops!"), \
_("The replacement string cannot contain the search string."))
return
i = 0
while self.search():
i += 1
self.replace()
QtGui.QMessageBox.information(self, _("Replace all"), \
_("%d occurence(s) have been replaced" % i)) opensesame-0.27.4/libqtopensesame/dialogs/__init__.py 0000664 0001750 0001750 00000001331 12061663322 025140 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
opensesame-0.27.4/libqtopensesame/dialogs/new_loop_sequence_dialog.py 0000664 0001750 0001750 00000005534 12061663322 030443 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
from PyQt4 import QtCore, QtGui
from libqtopensesame.ui import new_loop_sequence_ui
class new_loop_sequence_dialog(QtGui.QDialog):
"""Dialog to select an item-to-run for a new sequence or loop item"""
def __init__(self, parent, experiment, item_type, _parent):
"""
Constructor
Arguments:
parent -- the parent QWidget
experiment -- the experiment object
item_type -- 'sequence' or 'loop'
_parent -- the parent item, i.e. the item above the current item in the
experiment hierarchy
"""
QtGui.QDialog.__init__(self, parent)
self.experiment = experiment
self._parent = _parent
self.ui = new_loop_sequence_ui.Ui_new_loop_sequence_dialog()
self.ui.setupUi(self)
self.experiment.main_window.theme.apply_theme(self)
self.ui.label_icon.setPixmap( \
self.experiment.main_window.theme.qpixmap(item_type))
self.action = "cancel"
QtCore.QObject.connect(self.ui.button_new, QtCore.SIGNAL("clicked()"), \
self.new_item)
QtCore.QObject.connect(self.ui.button_select, \
QtCore.SIGNAL("clicked()"), self.select_item)
if item_type == "loop":
s = "A loop needs another item to run, usually a sequence. You can create a new item or select an existing item to add to the loop."
select = "sequence"
else:
s = "A sequence needs at least one other item to run, such as a sketchpad. You can create a new item or select an existing item to add to the sequence."
select = "sketchpad"
self.ui.label_explanation.setText(s)
self.experiment.item_type_combobox(True, True, self.ui.combobox_new, \
select)
# The parents list is excluded from the list of possible children, but
# this list if empty if there are no parents or the parent is the main
# experiment sequence
if self._parent == None or _parent not in self.experiment.items:
parents = []
else:
parents = self.experiment.items[_parent].parents()
self.experiment.item_combobox(None, parents, self.ui.combobox_select)
def new_item(self):
self.action = "new"
self.item_type = unicode(self.ui.combobox_new.currentText())
self.accept()
def select_item(self):
self.action = "select"
self.item_name = unicode(self.ui.combobox_select.currentText())
self.accept()
opensesame-0.27.4/libqtopensesame/actions/ 0000775 0001750 0001750 00000000000 12214554461 023052 5 ustar sebastiaan sebastiaan 0000000 0000000 opensesame-0.27.4/libqtopensesame/actions/__init__.py 0000664 0001750 0001750 00000001331 12061663322 025156 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
opensesame-0.27.4/libqtopensesame/actions/recent_action.py 0000664 0001750 0001750 00000002623 12061663322 026241 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from PyQt4 import QtGui
import os.path
class recent_action(QtGui.QAction):
"""Menu action for a recently opened file"""
def __init__(self, path, main_window, menu):
"""
Constructor
Arguments:
path -- path to the recent file
main_window -- the main window
menu -- the menu into which the action should be inserted
"""
QtGui.QAction.__init__(self, os.path.basename(path), menu)
self.main_window = main_window
self.triggered.connect(self.open_file)
self.path = path
def open_file(self, dummy = None):
"""
Open the file
Keyword arguments:
dummy -- a dummy argument passed by the signal handler (default=None)
"""
self.main_window.open_file(path=self.path)
opensesame-0.27.4/libqtopensesame/actions/plugin_action.py 0000664 0001750 0001750 00000002772 12061663322 026264 0 ustar sebastiaan sebastiaan 0000000 0000000 #-*- coding:utf-8 -*-
"""
This file is part of OpenSesame.
OpenSesame is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSesame is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSesame. If not, see .
"""
__author__ = "Sebastiaan Mathot"
__license__ = "GPLv3"
from PyQt4 import QtGui
from libopensesame import plugins
class plugin_action(QtGui.QAction):
"""Menu action for a plugin"""
def __init__(self, main_window, menu, plugin):
"""
Constructor
Arguments:
main_window -- the main window
menu -- the menu into which the action should be inserted
plugin -- the name of the plugin
"""
self.main_window = main_window
icon = QtGui.QIcon(plugins.plugin_icon_large(plugin))
self.plugin = plugin
QtGui.QAction.__init__(self, icon, "Add %s" % plugin, menu)
self.triggered.connect(self.add_plugin)
def add_plugin(self, dummy = None):
"""
Start a drag to add the plugin to the experiment
Keyword arguments:
dummy -- a dummy argument passed by the signal handler (default=None)
"""
self.main_window.drag_item(self.plugin)
opensesame-0.27.4/libqtopensesame/ui/ 0000775 0001750 0001750 00000000000 12214554461 022027 5 ustar sebastiaan sebastiaan 0000000 0000000 opensesame-0.27.4/libqtopensesame/ui/loop_wizard_dialog_ui.py 0000664 0001750 0001750 00000034000 12061663322 026740 0 ustar sebastiaan sebastiaan 0000000 0000000 # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'resources/ui/loop_wizard_dialog.ui'
#
# Created: Thu Aug 2 12:43:06 2012
# by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_loop_wizard_dialog(object):
def setupUi(self, loop_wizard_dialog):
loop_wizard_dialog.setObjectName(_fromUtf8("loop_wizard_dialog"))
loop_wizard_dialog.resize(478, 471)
self.verticalLayout = QtGui.QVBoxLayout(loop_wizard_dialog)
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.widget = QtGui.QWidget(loop_wizard_dialog)
self.widget.setObjectName(_fromUtf8("widget"))
self.horizontalLayout = QtGui.QHBoxLayout(self.widget)
self.horizontalLayout.setMargin(0)
self.horizontalLayout.setMargin(0)
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.label_wizard = QtGui.QLabel(self.widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_wizard.sizePolicy().hasHeightForWidth())
self.label_wizard.setSizePolicy(sizePolicy)
self.label_wizard.setText(_fromUtf8(""))
self.label_wizard.setPixmap(QtGui.QPixmap(_fromUtf8(":/icons/wizard_large.png")))
self.label_wizard.setObjectName(_fromUtf8("label_wizard"))
self.horizontalLayout.addWidget(self.label_wizard)
self.label_2 = QtGui.QLabel(self.widget)
self.label_2.setWordWrap(True)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.horizontalLayout.addWidget(self.label_2)
self.verticalLayout.addWidget(self.widget)
self.widget_2 = QtGui.QWidget(loop_wizard_dialog)
self.widget_2.setObjectName(_fromUtf8("widget_2"))
self.horizontalLayout_2 = QtGui.QHBoxLayout(self.widget_2)
self.horizontalLayout_2.setMargin(0)
self.horizontalLayout_2.setMargin(0)
self.horizontalLayout_2.setObjectName(_fromUtf8("horizontalLayout_2"))
self.checkBox = QtGui.QCheckBox(self.widget_2)
self.checkBox.setObjectName(_fromUtf8("checkBox"))
self.horizontalLayout_2.addWidget(self.checkBox)
spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
self.horizontalLayout_2.addItem(spacerItem)
self.verticalLayout.addWidget(self.widget_2)
self.table_example = good_looking_table(loop_wizard_dialog)
self.table_example.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.table_example.setGridStyle(QtCore.Qt.DotLine)
self.table_example.setObjectName(_fromUtf8("table_example"))
self.table_example.setColumnCount(10)
self.table_example.setRowCount(12)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(0, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(1, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(2, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(3, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(4, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(5, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(6, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(7, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(8, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(9, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(10, item)
item = QtGui.QTableWidgetItem()
self.table_example.setVerticalHeaderItem(11, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(0, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(1, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(2, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(3, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(4, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(5, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(6, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(7, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(8, item)
item = QtGui.QTableWidgetItem()
self.table_example.setHorizontalHeaderItem(9, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(0, 0, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(0, 1, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(0, 2, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(1, 0, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(1, 1, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(1, 2, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(2, 0, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(2, 1, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(2, 2, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(3, 0, item)
item = QtGui.QTableWidgetItem()
self.table_example.setItem(4, 0, item)
self.table_example.horizontalHeader().setVisible(False)
self.table_example.verticalHeader().setVisible(False)
self.verticalLayout.addWidget(self.table_example)
self.table_wizard = good_looking_table(loop_wizard_dialog)
self.table_wizard.setGridStyle(QtCore.Qt.DotLine)
self.table_wizard.setObjectName(_fromUtf8("table_wizard"))
self.table_wizard.setColumnCount(0)
self.table_wizard.setRowCount(0)
self.table_wizard.horizontalHeader().setVisible(False)
self.table_wizard.verticalHeader().setVisible(False)
self.verticalLayout.addWidget(self.table_wizard)
self.buttonBox = QtGui.QDialogButtonBox(loop_wizard_dialog)
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtGui.QDialogButtonBox.Cancel|QtGui.QDialogButtonBox.Ok)
self.buttonBox.setObjectName(_fromUtf8("buttonBox"))
self.verticalLayout.addWidget(self.buttonBox)
self.retranslateUi(loop_wizard_dialog)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("accepted()")), loop_wizard_dialog.accept)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("rejected()")), loop_wizard_dialog.reject)
QtCore.QObject.connect(self.checkBox, QtCore.SIGNAL(_fromUtf8("toggled(bool)")), self.table_example.setVisible)
QtCore.QMetaObject.connectSlotsByName(loop_wizard_dialog)
def retranslateUi(self, loop_wizard_dialog):
loop_wizard_dialog.setWindowTitle(QtGui.QApplication.translate("loop_wizard_dialog", "Loop Variable Wizard", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("loop_wizard_dialog", "Loop variable wizard
Enter the names of the variables (factors) in the first row in the table below. Under the variable names, enter the levels of the variables.
Note: This will overwrite the current loop table", None, QtGui.QApplication.UnicodeUTF8))
self.checkBox.setText(QtGui.QApplication.translate("loop_wizard_dialog", "Show example", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(0)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(1)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(2)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(3)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(4)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(5)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(6)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(7)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(8)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(9)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(10)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.verticalHeaderItem(11)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Row", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(0)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(1)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(2)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(3)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(4)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(5)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(6)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(7)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(8)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.horizontalHeaderItem(9)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "New Column", None, QtGui.QApplication.UnicodeUTF8))
__sortingEnabled = self.table_example.isSortingEnabled()
self.table_example.setSortingEnabled(False)
item = self.table_example.item(0, 0)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "soa", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(0, 1)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "target", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(0, 2)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "cue", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(1, 0)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "0", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(1, 1)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "left", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(1, 2)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "left", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(2, 0)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "100", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(2, 1)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "right", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(2, 2)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "right", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(3, 0)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "500", None, QtGui.QApplication.UnicodeUTF8))
item = self.table_example.item(4, 0)
item.setText(QtGui.QApplication.translate("loop_wizard_dialog", "1000", None, QtGui.QApplication.UnicodeUTF8))
self.table_example.setSortingEnabled(__sortingEnabled)
from good_looking_table import good_looking_table
opensesame-0.27.4/libqtopensesame/ui/general_widget_ui.py 0000664 0001750 0001750 00000032455 12173713501 026063 0 ustar sebastiaan sebastiaan 0000000 0000000 # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'resources/ui/general_widget.ui'
#
# Created: Sun Mar 24 20:08:05 2013
# by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_general_widget(object):
def setupUi(self, general_widget):
general_widget.setObjectName(_fromUtf8("general_widget"))
general_widget.resize(829, 852)
self.gridLayout_5 = QtGui.QGridLayout(general_widget)
self.gridLayout_5.setMargin(0)
self.gridLayout_5.setObjectName(_fromUtf8("gridLayout_5"))
self.widget_2 = QtGui.QWidget(general_widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widget_2.sizePolicy().hasHeightForWidth())
self.widget_2.setSizePolicy(sizePolicy)
self.widget_2.setObjectName(_fromUtf8("widget_2"))
self.horizontalLayout_5 = QtGui.QHBoxLayout(self.widget_2)
self.horizontalLayout_5.setMargin(0)
self.horizontalLayout_5.setObjectName(_fromUtf8("horizontalLayout_5"))
self.widget = QtGui.QWidget(self.widget_2)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widget.sizePolicy().hasHeightForWidth())
self.widget.setSizePolicy(sizePolicy)
self.widget.setMinimumSize(QtCore.QSize(20, 20))
self.widget.setObjectName(_fromUtf8("widget"))
self.formLayout = QtGui.QFormLayout(self.widget)
self.formLayout.setFieldGrowthPolicy(QtGui.QFormLayout.AllNonFixedFieldsGrow)
self.formLayout.setLabelAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.formLayout.setMargin(0)
self.formLayout.setMargin(0)
self.formLayout.setObjectName(_fromUtf8("formLayout"))
self.label = QtGui.QLabel(self.widget)
self.label.setObjectName(_fromUtf8("label"))
self.formLayout.setWidget(0, QtGui.QFormLayout.LabelRole, self.label)
self.label_3 = QtGui.QLabel(self.widget)
self.label_3.setObjectName(_fromUtf8("label_3"))
self.formLayout.setWidget(2, QtGui.QFormLayout.LabelRole, self.label_3)
self.frame_resolution = QtGui.QFrame(self.widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_resolution.sizePolicy().hasHeightForWidth())
self.frame_resolution.setSizePolicy(sizePolicy)
self.frame_resolution.setFrameShape(QtGui.QFrame.NoFrame)
self.frame_resolution.setObjectName(_fromUtf8("frame_resolution"))
self.horizontalLayout_3 = QtGui.QHBoxLayout(self.frame_resolution)
self.horizontalLayout_3.setMargin(0)
self.horizontalLayout_3.setObjectName(_fromUtf8("horizontalLayout_3"))
self.spinbox_width = QtGui.QSpinBox(self.frame_resolution)
self.spinbox_width.setMinimum(1)
self.spinbox_width.setMaximum(10000)
self.spinbox_width.setObjectName(_fromUtf8("spinbox_width"))
self.horizontalLayout_3.addWidget(self.spinbox_width)
self.label_6 = QtGui.QLabel(self.frame_resolution)
self.label_6.setObjectName(_fromUtf8("label_6"))
self.horizontalLayout_3.addWidget(self.label_6)
self.spinbox_height = QtGui.QSpinBox(self.frame_resolution)
self.spinbox_height.setMinimum(1)
self.spinbox_height.setMaximum(10000)
self.spinbox_height.setObjectName(_fromUtf8("spinbox_height"))
self.horizontalLayout_3.addWidget(self.spinbox_height)
self.formLayout.setWidget(2, QtGui.QFormLayout.FieldRole, self.frame_resolution)
self.label_8 = QtGui.QLabel(self.widget)
self.label_8.setObjectName(_fromUtf8("label_8"))
self.formLayout.setWidget(3, QtGui.QFormLayout.LabelRole, self.label_8)
self.frame_colors = QtGui.QFrame(self.widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_colors.sizePolicy().hasHeightForWidth())
self.frame_colors.setSizePolicy(sizePolicy)
self.frame_colors.setFrameShape(QtGui.QFrame.NoFrame)
self.frame_colors.setObjectName(_fromUtf8("frame_colors"))
self.gridLayout_6 = QtGui.QGridLayout(self.frame_colors)
self.gridLayout_6.setMargin(0)
self.gridLayout_6.setObjectName(_fromUtf8("gridLayout_6"))
self.edit_foreground = color_edit(self.frame_colors)
self.edit_foreground.setObjectName(_fromUtf8("edit_foreground"))
self.gridLayout_6.addWidget(self.edit_foreground, 0, 1, 1, 1)
self.label_4 = QtGui.QLabel(self.frame_colors)
self.label_4.setObjectName(_fromUtf8("label_4"))
self.gridLayout_6.addWidget(self.label_4, 0, 0, 1, 1)
self.label_5 = QtGui.QLabel(self.frame_colors)
self.label_5.setObjectName(_fromUtf8("label_5"))
self.gridLayout_6.addWidget(self.label_5, 1, 0, 1, 1)
self.edit_background = color_edit(self.frame_colors)
self.edit_background.setObjectName(_fromUtf8("edit_background"))
self.gridLayout_6.addWidget(self.edit_background, 1, 1, 1, 1)
self.label_2 = QtGui.QLabel(self.frame_colors)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_2.sizePolicy().hasHeightForWidth())
self.label_2.setSizePolicy(sizePolicy)
self.label_2.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignTop)
self.label_2.setWordWrap(True)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.gridLayout_6.addWidget(self.label_2, 2, 0, 1, 2)
self.formLayout.setWidget(3, QtGui.QFormLayout.FieldRole, self.frame_colors)
self.label_9 = QtGui.QLabel(self.widget)
self.label_9.setObjectName(_fromUtf8("label_9"))
self.formLayout.setWidget(4, QtGui.QFormLayout.LabelRole, self.label_9)
self.frame_font = QtGui.QFrame(self.widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_font.sizePolicy().hasHeightForWidth())
self.frame_font.setSizePolicy(sizePolicy)
self.frame_font.setFrameShape(QtGui.QFrame.NoFrame)
self.frame_font.setFrameShadow(QtGui.QFrame.Raised)
self.frame_font.setObjectName(_fromUtf8("frame_font"))
self.horizontalLayout_4 = QtGui.QHBoxLayout(self.frame_font)
self.horizontalLayout_4.setMargin(0)
self.horizontalLayout_4.setObjectName(_fromUtf8("horizontalLayout_4"))
self.widget_font = font_widget(self.frame_font)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widget_font.sizePolicy().hasHeightForWidth())
self.widget_font.setSizePolicy(sizePolicy)
self.widget_font.setMinimumSize(QtCore.QSize(10, 10))
self.widget_font.setObjectName(_fromUtf8("widget_font"))
self.horizontalLayout_4.addWidget(self.widget_font)
self.formLayout.setWidget(4, QtGui.QFormLayout.FieldRole, self.frame_font)
self.label_11 = QtGui.QLabel(self.widget)
self.label_11.setObjectName(_fromUtf8("label_11"))
self.formLayout.setWidget(6, QtGui.QFormLayout.LabelRole, self.label_11)
self.combobox_backend = QtGui.QComboBox(self.widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.combobox_backend.sizePolicy().hasHeightForWidth())
self.combobox_backend.setSizePolicy(sizePolicy)
self.combobox_backend.setObjectName(_fromUtf8("combobox_backend"))
self.formLayout.setWidget(0, QtGui.QFormLayout.FieldRole, self.combobox_backend)
self.frame_advanced = QtGui.QFrame(self.widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.frame_advanced.sizePolicy().hasHeightForWidth())
self.frame_advanced.setSizePolicy(sizePolicy)
self.frame_advanced.setFrameShape(QtGui.QFrame.NoFrame)
self.frame_advanced.setFrameShadow(QtGui.QFrame.Raised)
self.frame_advanced.setObjectName(_fromUtf8("frame_advanced"))
self.horizontalLayout_6 = QtGui.QHBoxLayout(self.frame_advanced)
self.horizontalLayout_6.setSpacing(0)
self.horizontalLayout_6.setMargin(0)
self.horizontalLayout_6.setObjectName(_fromUtf8("horizontalLayout_6"))
self.button_backend_settings = QtGui.QCommandLinkButton(self.frame_advanced)
self.button_backend_settings.setObjectName(_fromUtf8("button_backend_settings"))
self.horizontalLayout_6.addWidget(self.button_backend_settings)
self.button_script_editor = QtGui.QCommandLinkButton(self.frame_advanced)
self.button_script_editor.setObjectName(_fromUtf8("button_script_editor"))
self.horizontalLayout_6.addWidget(self.button_script_editor)
self.formLayout.setWidget(6, QtGui.QFormLayout.FieldRole, self.frame_advanced)
self.checkbox_transparent_variables = QtGui.QCheckBox(self.widget)
self.checkbox_transparent_variables.setObjectName(_fromUtf8("checkbox_transparent_variables"))
self.formLayout.setWidget(5, QtGui.QFormLayout.FieldRole, self.checkbox_transparent_variables)
self.label_7 = QtGui.QLabel(self.widget)
self.label_7.setTextFormat(QtCore.Qt.AutoText)
self.label_7.setObjectName(_fromUtf8("label_7"))
self.formLayout.setWidget(5, QtGui.QFormLayout.LabelRole, self.label_7)
self.horizontalLayout_5.addWidget(self.widget)
self.gridLayout_5.addWidget(self.widget_2, 0, 0, 1, 1)
self.retranslateUi(general_widget)
QtCore.QMetaObject.connectSlotsByName(general_widget)
def retranslateUi(self, general_widget):
general_widget.setWindowTitle(QtGui.QApplication.translate("general_widget", "Form", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("general_widget", "
Back-end
", None, QtGui.QApplication.UnicodeUTF8))
self.label_3.setText(QtGui.QApplication.translate("general_widget", "Resolution
", None, QtGui.QApplication.UnicodeUTF8))
self.spinbox_width.setToolTip(QtGui.QApplication.translate("general_widget", "The display resolution (width) in pixels", None, QtGui.QApplication.UnicodeUTF8))
self.spinbox_width.setSuffix(QtGui.QApplication.translate("general_widget", "px", None, QtGui.QApplication.UnicodeUTF8))
self.label_6.setText(QtGui.QApplication.translate("general_widget", "x", None, QtGui.QApplication.UnicodeUTF8))
self.spinbox_height.setToolTip(QtGui.QApplication.translate("general_widget", "The display resolution (height) in pixels", None, QtGui.QApplication.UnicodeUTF8))
self.spinbox_height.setSuffix(QtGui.QApplication.translate("general_widget", "px", None, QtGui.QApplication.UnicodeUTF8))
self.label_8.setText(QtGui.QApplication.translate("general_widget", "Colors
", None, QtGui.QApplication.UnicodeUTF8))
self.label_4.setText(QtGui.QApplication.translate("general_widget", "Foreground", None, QtGui.QApplication.UnicodeUTF8))
self.label_5.setText(QtGui.QApplication.translate("general_widget", "Background", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("general_widget", "Examples: \'white\', \'#FFFFFF\'", None, QtGui.QApplication.UnicodeUTF8))
self.label_9.setText(QtGui.QApplication.translate("general_widget", "Font
", None, QtGui.QApplication.UnicodeUTF8))
self.label_11.setText(QtGui.QApplication.translate("general_widget", "Advanced
", None, QtGui.QApplication.UnicodeUTF8))
self.button_backend_settings.setText(QtGui.QApplication.translate("general_widget", "Back-end settings", None, QtGui.QApplication.UnicodeUTF8))
self.button_script_editor.setText(QtGui.QApplication.translate("general_widget", "Script editor", None, QtGui.QApplication.UnicodeUTF8))
self.checkbox_transparent_variables.setText(QtGui.QApplication.translate("general_widget", "Transparent variable management", None, QtGui.QApplication.UnicodeUTF8))
self.label_7.setText(QtGui.QApplication.translate("general_widget", "Variables
", None, QtGui.QApplication.UnicodeUTF8))
from libqtopensesame.widgets.font_widget import font_widget
from libqtopensesame.widgets.color_edit import color_edit
opensesame-0.27.4/libqtopensesame/ui/notification_dialog_ui.py 0000664 0001750 0001750 00000007525 12061663322 027111 0 ustar sebastiaan sebastiaan 0000000 0000000 # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'resources/ui/notification_dialog.ui'
#
# Created: Thu Aug 2 12:43:06 2012
# by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_notification_dialog(object):
def setupUi(self, notification_dialog):
notification_dialog.setObjectName(_fromUtf8("notification_dialog"))
notification_dialog.resize(400, 300)
self.verticalLayout = QtGui.QVBoxLayout(notification_dialog)
self.verticalLayout.setMargin(8)
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.widget = QtGui.QWidget(notification_dialog)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widget.sizePolicy().hasHeightForWidth())
self.widget.setSizePolicy(sizePolicy)
self.widget.setStyleSheet(_fromUtf8("color: rgb(255, 255, 255);\n"
"background-color: #729fcf;"))
self.widget.setObjectName(_fromUtf8("widget"))
self.horizontalLayout = QtGui.QHBoxLayout(self.widget)
self.horizontalLayout.setMargin(5)
self.horizontalLayout.setMargin(0)
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.label_notification = QtGui.QLabel(self.widget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_notification.sizePolicy().hasHeightForWidth())
self.label_notification.setSizePolicy(sizePolicy)
self.label_notification.setText(_fromUtf8(""))
self.label_notification.setPixmap(QtGui.QPixmap(_fromUtf8(":/icons/about_large.png")))
self.label_notification.setObjectName(_fromUtf8("label_notification"))
self.horizontalLayout.addWidget(self.label_notification)
self.label_2 = QtGui.QLabel(self.widget)
font = QtGui.QFont()
font.setPointSize(11)
font.setBold(True)
font.setWeight(75)
self.label_2.setFont(font)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.horizontalLayout.addWidget(self.label_2)
self.verticalLayout.addWidget(self.widget)
self.textedit_notification = QtGui.QTextBrowser(notification_dialog)
font = QtGui.QFont()
font.setFamily(_fromUtf8("Monospace"))
self.textedit_notification.setFont(font)
self.textedit_notification.setObjectName(_fromUtf8("textedit_notification"))
self.verticalLayout.addWidget(self.textedit_notification)
self.buttonBox = QtGui.QDialogButtonBox(notification_dialog)
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtGui.QDialogButtonBox.Close)
self.buttonBox.setObjectName(_fromUtf8("buttonBox"))
self.verticalLayout.addWidget(self.buttonBox)
self.retranslateUi(notification_dialog)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("accepted()")), notification_dialog.accept)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("rejected()")), notification_dialog.reject)
QtCore.QMetaObject.connectSlotsByName(notification_dialog)
def retranslateUi(self, notification_dialog):
notification_dialog.setWindowTitle(QtGui.QApplication.translate("notification_dialog", "OpenSesame says ...", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate("notification_dialog", "OpenSesame says ...", None, QtGui.QApplication.UnicodeUTF8))
opensesame-0.27.4/libqtopensesame/ui/credits_widget_ui.py 0000664 0001750 0001750 00000014116 12117134373 026077 0 ustar sebastiaan sebastiaan 0000000 0000000 # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'resources/ui/credits_widget.ui'
#
# Created: Tue Feb 5 15:54:19 2013
# by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_widget_credits(object):
def setupUi(self, widget_credits):
widget_credits.setObjectName(_fromUtf8("widget_credits"))
widget_credits.resize(868, 55)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(widget_credits.sizePolicy().hasHeightForWidth())
widget_credits.setSizePolicy(sizePolicy)
self.verticalLayout = QtGui.QVBoxLayout(widget_credits)
self.verticalLayout.setMargin(0)
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
spacerItem = QtGui.QSpacerItem(20, 2, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem)
self.widget_container = QtGui.QWidget(widget_credits)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widget_container.sizePolicy().hasHeightForWidth())
self.widget_container.setSizePolicy(sizePolicy)
self.widget_container.setObjectName(_fromUtf8("widget_container"))
self.horizontalLayout = QtGui.QHBoxLayout(self.widget_container)
self.horizontalLayout.setSpacing(0)
self.horizontalLayout.setMargin(0)
self.horizontalLayout.setMargin(0)
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.widget_credits_2 = QtGui.QWidget(self.widget_container)
self.widget_credits_2.setObjectName(_fromUtf8("widget_credits_2"))
self.verticalLayout_3 = QtGui.QVBoxLayout(self.widget_credits_2)
self.verticalLayout_3.setSpacing(0)
self.verticalLayout_3.setMargin(0)
self.verticalLayout_3.setMargin(0)
self.verticalLayout_3.setObjectName(_fromUtf8("verticalLayout_3"))
self.widget_social = QtGui.QWidget(self.widget_credits_2)
self.widget_social.setObjectName(_fromUtf8("widget_social"))
self.horizontalLayout_2 = QtGui.QHBoxLayout(self.widget_social)
self.horizontalLayout_2.setSpacing(4)
self.horizontalLayout_2.setMargin(0)
self.horizontalLayout_2.setMargin(0)
self.horizontalLayout_2.setObjectName(_fromUtf8("horizontalLayout_2"))
self.label_facebook = QtGui.QLabel(self.widget_social)
self.label_facebook.setObjectName(_fromUtf8("label_facebook"))
self.horizontalLayout_2.addWidget(self.label_facebook)
self.label_twitter = QtGui.QLabel(self.widget_social)
self.label_twitter.setObjectName(_fromUtf8("label_twitter"))
self.horizontalLayout_2.addWidget(self.label_twitter)
self.label_website = QtGui.QLabel(self.widget_social)
self.label_website.setObjectName(_fromUtf8("label_website"))
self.horizontalLayout_2.addWidget(self.label_website)
self.label_cogscinl = QtGui.QLabel(self.widget_social)
self.label_cogscinl.setObjectName(_fromUtf8("label_cogscinl"))
self.horizontalLayout_2.addWidget(self.label_cogscinl)
spacerItem1 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
self.horizontalLayout_2.addItem(spacerItem1)
self.verticalLayout_3.addWidget(self.widget_social)
self.horizontalLayout.addWidget(self.widget_credits_2)
spacerItem2 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem2)
self.label_opensesame = QtGui.QLabel(self.widget_container)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.label_opensesame.sizePolicy().hasHeightForWidth())
self.label_opensesame.setSizePolicy(sizePolicy)
self.label_opensesame.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing)
self.label_opensesame.setObjectName(_fromUtf8("label_opensesame"))
self.horizontalLayout.addWidget(self.label_opensesame)
self.verticalLayout.addWidget(self.widget_container)
self.retranslateUi(widget_credits)
QtCore.QMetaObject.connectSlotsByName(widget_credits)
def retranslateUi(self, widget_credits):
widget_credits.setWindowTitle(QtGui.QApplication.translate("widget_credits", "Form", None, QtGui.QApplication.UnicodeUTF8))
self.label_facebook.setToolTip(QtGui.QApplication.translate("widget_credits", "Visit Facebook page", None, QtGui.QApplication.UnicodeUTF8))
self.label_facebook.setText(QtGui.QApplication.translate("widget_credits", "F", None, QtGui.QApplication.UnicodeUTF8))
self.label_twitter.setToolTip(QtGui.QApplication.translate("widget_credits", "Visit Twitter page", None, QtGui.QApplication.UnicodeUTF8))
self.label_twitter.setText(QtGui.QApplication.translate("widget_credits", "T", None, QtGui.QApplication.UnicodeUTF8))
self.label_website.setToolTip(QtGui.QApplication.translate("widget_credits", "Visit cogsci.nl", None, QtGui.QApplication.UnicodeUTF8))
self.label_website.setText(QtGui.QApplication.translate("widget_credits", "H", None, QtGui.QApplication.UnicodeUTF8))
self.label_cogscinl.setText(QtGui.QApplication.translate("widget_credits", "