def __init__(self, main_window, info={}): """ desc: Constructor. arguments: main_window: The main-window object. keywords: info: A dictionary with extension properties that have been read from info.[json|txt]. """ debug.msg(u'creating %s' % self.name()) self._ = translation_context(self.name(), category=u'extension') self.info = info self.setup(main_window) self.register_ui_files() self.create_action() self.register_config()
from libopensesame.py3compat import * from qtpy import QtGui, QtCore, QtWidgets from libqtopensesame.misc.base_component import base_component from libqtopensesame.misc.config import cfg from libqtopensesame.items import experiment from libopensesame import debug, metadata from libopensesame.exceptions import osexception import libopensesame.experiment import libopensesame.plugins import libopensesame.misc import os import sys import warnings from libqtopensesame.misc.translate import translation_context _ = translation_context(u'qtopensesame', category=u'core') class qtopensesame(QtWidgets.QMainWindow, base_component): """The main class of the OpenSesame GUI""" def __init__(self, app, parent=None): """ Constructor. This does very little, except prepare the app to be shown as rapidly as possible. The actual GUI initialization is handled by resume_init(). Arguments: app -- the QApplication
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libqtopensesame.misc.base_subcomponent import base_subcomponent from libopensesame import plugins from qtpy import QtWidgets, QtGui from libqtopensesame.misc.translate import translation_context _ = translation_context(u"tree_append_menu", category=u"core") class append_existing_action(base_subcomponent, QtWidgets.QAction): """ desc: An action for appending existing items, either as linked or unlinked copies. """ def __init__(self, append_menu, menu, item_name): """ desc: Constructor.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import os import sys from libopensesame import misc, metadata from libqtopensesame.extensions import BaseExtension from libqtopensesame.misc.translate import translation_context from libqtopensesame.misc import template_info _ = translation_context(u'RapunzelWelcome', category=u'extension') class RapunzelWelcome(BaseExtension): @BaseExtension.as_thread(wait=500) def event_startup(self): # Don't show the startup tab if any pinned files have been restored if self.extension_manager.provide('ide_restored_pins'): return with safe_open(self.ext_resource(u'rapunzel_welcome.md')) as fd: md = fd.read() self.tabwidget.open_markdown(md, title=_(u'Get started!'), icon=u'help-about') self._widget = self.tabwidget.currentWidget()
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame.exceptions import osexception from libopensesame import item, widgets from libqtopensesame.items.qtautoplugin import qtautoplugin try: from libqtopensesame.misc.translate import translation_context _ = translation_context(u'form_base', category=u'plugin') except ImportError: pass class form_base(item.item): """A generic form plug-in""" initial_view = u'script' def __init__(self, name, experiment, script=None, item_type=u'form_base', description=u'A generic form plug-in'): """ Constructor
""" from libopensesame.py3compat import * import os import tempfile import webbrowser from qtpy.QtWidgets import QFileDialog from qtpy.QtCore import QRegExp from qtpy.QtGui import QRegExpValidator, QIcon from libqtopensesame.widgets.base_widget import base_widget from libopensesame.osexpfile import osexpwriter from osweb import export, __version__ from libqtopensesame.misc.translate import translation_context from libqtopensesame.misc.config import cfg _ = translation_context(u'oswebext', category=u'extension') MEGABYTE = 1024**2 class oswebext_widget(base_widget): """ desc: Controls for interacting with OSWeb """ def __init__(self, main_window, oswebext): """ desc: Constructor. arguments:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libqtopensesame.misc.base_subcomponent import base_subcomponent from libopensesame import plugins from qtpy import QtWidgets, QtGui from libqtopensesame.misc.translate import translation_context _ = translation_context(u'tree_append_menu', category=u'core') class append_existing_action(base_subcomponent, QtWidgets.QAction): """ desc: An action for appending existing items, either as linked or unlinked copies. """ def __init__(self, append_menu, menu, item_name): """ desc: Constructor. arguments: append_menu:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame.exceptions import osexception from libopensesame.item_store import item_store from libopensesame import plugins from libqtopensesame.misc.translate import translation_context _ = translation_context(u'qtitem_store', category=u'core') class qtitem_store(item_store): """ desc: The GUI counterpart of the item store, which also distributes item changes etc. """ def __init__(self, experiment): """ desc: Constructor.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame import debug, metadata from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc.config import cfg from qtpy import QtGui, QtWidgets, QtCore from libqtopensesame.misc.translate import translation_context _ = translation_context(u'tab_widget', category=u'core') class tab_widget(base_subcomponent, QtWidgets.QTabWidget): """A custom tab widget with some extra functionality""" def __init__(self, parent=None): """ Constructor Keywords arguments: parent -- the parent QWidget """ QtWidgets.QTabWidget.__init__(self, parent)
# Python3 compatibility from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from qtpy import QtWidgets, QtCore, QtGui import QNotifications from libopensesame import debug from libopensesame.exceptions import osexception from libopensesame.py3compat import * from libqtopensesame.extensions import base_extension from libqtopensesame.misc.translate import translation_context _ = translation_context(u'notifications', category=u'extension') __author__ = u"Daniel Schreij" __license__ = u"GPLv3" import os class notifications(base_extension): ### OpenSesame events timeout = 5000 def event_startup(self): self.notfication_area = QNotifications.QNotificationArea(self.tabwidget) self.notfication_area.setEntryEffect(u'fadeIn', 200) self.notfication_area.setExitEffect(u'fadeOut', 200) def event_save_experiment(self, path):
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import os from libqtopensesame.items.sequence import sequence from libqtopensesame.items.qtplugin import qtplugin from libopensesame.sequence import sequence as sequence_runtime from libqtopensesame.widgets.tree_item_item import tree_item_item from libqtopensesame.validators import duration_validator from oscoroutines import coroutines, items_adapter, tree_overview_adapter from libqtopensesame.misc.translate import translation_context _ = translation_context(u'coroutines', category=u'plugins') class qtcoroutines(coroutines, sequence): """ desc: The coroutines plugin GUI. """ description = _(u'Run items simultaneously') def __init__(self, name, experiment, string=None): """See item."""
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libqtopensesame.misc.translate import translation_context _ = translation_context(u'template', category=u'core') if py3: templates = [ (u'templates/default-py3.osexp', _(u'Default template')), (u'templates/extended_template-py3.osexp', _(u'Extended template')), (u'templates/form_template.osexp', _(u'Questionnaire template')), (u'templates/android_template.osexp', _(u'Android template')), ] else: templates = [ (u'templates/default.osexp', _(u'Default template')), (u'templates/extended_template.osexp', _(u'Extended template')), (u'templates/form_template.osexp', _(u'Questionnaire template')),
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtWidgets from libopensesame import debug from libqtopensesame.extensions import base_extension from libqtopensesame.misc.config import cfg from libqtopensesame.misc.translate import translation_context _ = translation_context(u'update_checker', category=u'extension') class update_checker(base_extension): def activate(self): self.check_for_updates() def event_startup(self): self.check_for_updates(always=False) def check_for_updates(self, always=True): if py3: from urllib.request import urlopen
You should have received a copy of the GNU General Public License along with OpenSesame. If not, see <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame import debug, misc from libqtopensesame.misc.config import cfg from libqtopensesame.widgets.base_widget import base_widget from libqtopensesame._input.popup_menu import popup_menu from libqtopensesame._input.confirmation import confirmation from qtpy import QtCore, QtWidgets import os import os.path from libqtopensesame.misc.translate import translation_context _ = translation_context(u"pool_widget", category=u"core") class pool_widget(base_widget): """ desc: The file-pool widget. """ def __init__(self, main_window): """ desc: Constructor.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import os import sys from libopensesame import misc, metadata from libqtopensesame.extensions import base_extension from libqtopensesame.misc.translate import translation_context from libqtopensesame.misc import template_info _ = translation_context(u'get_started', category=u'extension') class get_started(base_extension): """ desc: Shows the get-started tab and opens an experiment on startup, if one was passed on the command line. """ def activate(self): """ desc: Is called when the extension is activated through the menu/ toolbar action. """
along with OpenSesame. If not, see <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import random import re import sys from libopensesame import debug, misc from libopensesame.inline_script import inline_script as inline_script_runtime from libqtopensesame.items.qtplugin import qtplugin from libqtopensesame.misc.config import cfg from libqtopensesame.widgets.tree_inline_script_item import \ tree_inline_script_item from qtpy import QtCore, QtWidgets from libqtopensesame.misc.translate import translation_context _ = translation_context(u'inline_script', category=u'item') class inline_script(inline_script_runtime, qtplugin): """The inline_script GUI controls""" description = _(u'Executes Python code' ) help_url = u'manual/python/about' def __init__(self, name, experiment, string=None): """See item.""" inline_script_runtime.__init__(self, name, experiment, string) qtplugin.__init__(self)
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtGui, QtWidgets from libqtopensesame.misc.config import cfg from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.widgets.tree_append_menu import tree_append_menu from libqtopensesame.misc.translate import translation_context _ = translation_context(u'item_context_menu', category=u'core') class item_context_menu(base_subcomponent, QtWidgets.QMenu): """ desc: Provides a basic context menu for an item. """ def __init__(self, main_window, treeitem): """ desc: Constructor.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame.keyboard_response import keyboard_response as \ keyboard_response_runtime from libqtopensesame.validators import timeout_validator from libqtopensesame.items.qtplugin import qtplugin from openexp.keyboard import keyboard from qtpy import QtCore, QtWidgets from libqtopensesame.misc.translate import translation_context _ = translation_context(u'keyboard_response', category=u'item') class keyboard_response(keyboard_response_runtime, qtplugin): """keyboard_response item GUI""" description = _(u'Collects keyboard responses') help_url = u'manual/response/keyboard' lazy_init = True def __init__(self, name, experiment, string=None): """ Constructor Arguments:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame.exceptions import osexception from libqtopensesame.extensions import base_extension from libopensesame import misc import time import os from libqtopensesame.misc.translate import translation_context _ = translation_context(u'after_experiment', category=u'extension') class after_experiment(base_extension): """ desc: Shows notifications after an experiment has finished. """ def event_end_experiment(self, ret_val): """ desc: Handles the end of an experiment. arguments: ret_val: desc: An Exception, or None if no exception occurred.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import platform from qtpy import QtCore from libqtopensesame.widgets.base_widget import base_widget from libopensesame import plugins, misc from libqtopensesame.misc.markdown_parser import markdown_parser import os.path from libqtopensesame.misc.translate import translation_context _ = translation_context(u'webbrowser', category=u'core') import os if os.environ[u'QT_API'] == u'pyqt': from PyQt4.QtWebKit import QWebView as WebView from PyQt4.QtWebKit import QWebPage as WebPage else: # QtWebKit is dropped in favour of QtWebEngine from Qt 5.6 on try: from PyQt5.QtWebKitWidgets import QWebView as WebView from PyQt5.QtWebKitWidgets import QWebPage as WebPage except ImportError as e: from PyQt5.QtWebEngineWidgets import QWebEngineView as WebView from PyQt5.QtWebEngineWidgets import QWebEnginePage as WebPage # These urls are viewed internally in the browser component. All other urls are
""" from libopensesame.py3compat import * import os import multiprocessing from queue import Empty import psutil from qtpy.QtCore import Qt, QTimer from qtpy.QtWidgets import QDockWidget from datamatrix import DataMatrix from qdatamatrix import QDataMatrix from libqtopensesame.misc.config import cfg from libopensesame.oslogging import oslogger from libqtopensesame.extensions import BaseExtension from libqtopensesame.misc.translate import translation_context _ = translation_context(u'SubprocessManager', category=u'extension') PARACHUTE_STOP = -1 PARACHUTE_HEARTBEAT = -2 PARACHUTE_HEARTBEAT_INTERVAL = 5 def parachute(queue, main_pid): """This function runs as a subprocess and receives the PIDs off all subprocesses. Whether the main process is alive is kept track of with a heartbeat. If no heartbeat comes in, then all subprocesses are killed to make sure that no runaway processes are left on shutdown. """ oslogger.start('parachute') pids = [main_pid]
along with OpenSesame. If not, see <http://www.gnu.org/licenses/>. IMPORTANT NOTE: The parallel plug-in is not reliable, and will be replaced by the coroutines plugin. """ from libopensesame.py3compat import * import os.path import threading from libopensesame import sequence, debug from libqtopensesame.items import sequence as qtsequence from libqtopensesame.items import qtplugin try: from libqtopensesame.misc.translate import translation_context _ = translation_context(u'parallel', category=u'plugin') except ImportError: pass class parallel_process(threading.Thread): """A wrapper for a single process""" def __init__(self, item): """ Constructor Arguments: item -- the item to run """
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import libopensesame.experiment import libopensesame.plugins from libqtopensesame.misc.qtitem_store import qtitem_store from libqtopensesame.misc.qtsyntax import qtsyntax from qtpy import QtCore, QtWidgets, QtGui import os from libqtopensesame.misc.translate import translation_context _ = translation_context(u'experiment', category=u'item') class experiment(libopensesame.experiment.experiment): """Contains various GUI controls for the experiment""" def __init__(self, main_window, name, string=None, pool_folder=None, experiment_path=None, resources={}): """ desc: Constructor. The experiment is created automatically be OpenSesame and you will generally not need to create it yourself. arguments: main_window:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtGui, QtWidgets from collections import OrderedDict from libopensesame import debug, plugins from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc.config import cfg from libqtopensesame.widgets.toolbar_items_label import toolbar_items_label from libqtopensesame.widgets.toolbar_items_item import toolbar_items_item from libqtopensesame.misc.translate import translation_context _ = translation_context(u'toolbar_items', category=u'core') class toolbar_items(base_subcomponent, QtWidgets.QToolBar): """ desc: The item toolbar, which allows you to insert items into the experiment through drag and drop. """ def __init__(self, parent): """ desc: Constructor. arguments: parent:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import re from libopensesame.oslogging import oslogger from libqtopensesame.extensions import BaseExtension from libqtopensesame.misc.translate import translation_context _ = translation_context(u'SymbolSelector', category=u'extension') PYTHON_SYMBOLS = r'^[ \t]*(?P<type>def|class)[ \t]+(?P<name>\w+)' R_SYMBOLS = r'^[ \t]*(?P<name>[\w.]+)[ \t]*<-[ \t]*function' MARKDOWN_HEADINGS = r'^#+[ \t]*(?P<name>.+)$' MARKDOWN_HR = r'^---[ \t]*\n[ \t\n]*(?P<name>.{1,50})' class SymbolSelector(BaseExtension): preferences_ui = 'extensions.SymbolSelector.preferences' def activate(self): self.main_window.set_busy(True) editor = self.extension_manager.provide(u'ide_current_editor')
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtWidgets from libqtopensesame.widgets.tree_item_item import tree_item_item from libqtopensesame.widgets.tree_inline_script_phase_item import \ tree_inline_script_phase_item from libqtopensesame.widgets.tree_inline_script_symbol_item import \ tree_inline_script_symbol_item from libqtopensesame.misc.translate import translation_context _ = translation_context(u'tree_inline_script_item', category=u'core') class tree_inline_script_item(tree_item_item): """ desc: Corresponds to an inline-script widget in the overview area. """ def __init__(self, item, extra_info=None, parent_item=None, index=None, symbols=True): """ desc:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtWidgets, QtGui from libopensesame import debug from libqtopensesame.widgets.base_widget import base_widget from libqtopensesame.misc.translate import translation_context _ = translation_context(u'color_edit', category=u'core') class color_edit(base_widget): """ desc: A colorpicker widget that emulates a QLineEdit. """ textChanged = QtCore.Signal('QString') textEdited = QtCore.Signal('QString') def __init__(self, main_window): """ desc:
(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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame import debug from libqtopensesame.widgets.header_widget import header_widget from libqtopensesame.misc.translate import translation_context _ = translation_context(u'general_header_widget', category=u'core') class general_header_widget(header_widget): """ desc: The widget containing the clickable title and description of the experiment. """ def __init__(self, general_tab, main_window): """ desc: Constructor.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame import debug, metadata from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc import config from qtpy import QtGui, QtWidgets, QtCore from libqtopensesame.misc.translate import translation_context _ = translation_context(u'tab_widget', category=u'core') class tab_widget(base_subcomponent, QtWidgets.QTabWidget): """A custom tab widget with some extra functionality""" def __init__(self, parent=None): """ Constructor Keywords arguments: parent -- the parent QWidget """ QtWidgets.QTabWidget.__init__(self, parent) base_subcomponent.setup(self, parent) try:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libqtopensesame.extensions import base_extension, suspend_events from qtpy.QtWidgets import QMenu, QToolBar from undo_stack import undo_stack import difflib from libqtopensesame.misc.translate import translation_context _ = translation_context(u'undo_manager', category=u'extension') class undo_manager(base_extension): """ desc: An extension that implements undo/ redo. """ def event_startup(self): """ desc: Initializes the extension on startup. """ self.undo_action = self.qaction(u'edit-undo', _(u'Undo'),
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtWidgets from libqtopensesame.widgets.tree_base_item import tree_base_item from libqtopensesame.items.qtstructure_item import qtstructure_item from libqtopensesame.misc.translate import translation_context _ = translation_context(u'tree_item_item', category=u'core') class tree_item_item(tree_base_item): """ desc: Corresponds to an item widget in the overview area. """ def __init__(self, item, extra_info=None, parent_item=None, index=None): """ desc: Constructor. arguments: item: desc: An item.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtWidgets from libqtopensesame.widgets.tree_base_item import tree_base_item from libqtopensesame.misc import drag_and_drop from libqtopensesame.misc.translate import translation_context _ = translation_context(u'tree_unused_items_item', category=u'core') class tree_unused_items_item(tree_base_item): """ desc: Corresponds to the unused-items widget in the overview area. """ def __init__(self, main_window): """ desc: Constructor. arguments:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import os from libqtopensesame.misc.config import cfg from libqtopensesame.extensions import BaseExtension from libopensesame.oslogging import oslogger from qtpy.QtWidgets import QDockWidget, QShortcut from qtpy.QtCore import Qt from qtpy.QtGui import QKeySequence from libqtopensesame.misc.translate import translation_context _ = translation_context(u'JupyterConsole', category=u'extension') class JupyterConsole(BaseExtension): preferences_ui = 'extensions.JupyterConsole.preferences' @BaseExtension.as_thread(wait=500) def event_startup(self): from jupyter_tabwidget import ConsoleTabWidget self.set_busy(True) self._jupyter_console = ConsoleTabWidget(self.main_window) self._dock_widget = QDockWidget(u'Console', self.main_window) self._dock_widget.setObjectName(u'JupyterConsole')
(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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtWidgets from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc.translate import translation_context _ = translation_context(u'confirmation', category=u'core') class confirmation(QtWidgets.QMessageBox, base_subcomponent): """ desc: A simple yes/ no/ cancel confirmation dialog. """ def __init__(self, main_window, msg, title=None, allow_cancel=False, default=u'no'): """ desc: Constructor.
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame.exceptions import osexception from libopensesame.item_store import item_store from libopensesame import plugins from libqtopensesame.misc.translate import translation_context _ = translation_context(u'qtitem_store', category=u'core') class qtitem_store(item_store): """ desc: The GUI counterpart of the item store, which also distributes item changes etc. """ def __init__(self, experiment): """ desc: Constructor. arguments: main_window:
try: from collections import OrderedDict except ImportError: OrderDict = dict from libopensesame import metadata from libopensesame.oslogging import oslogger from libqtopensesame.extensions import BaseExtension from libqtopensesame.misc.config import cfg from qtpy.QtCore import Qt, QTimer from qtpy.QtWidgets import QFileDialog, QMessageBox, QPushButton, QApplication from opensesame_ide import FolderBrowserDockWidget, MenuBar from libqtopensesame.misc.translate import translation_context from pyqode.core import widgets, panels from pyqode.core.api.utils import TextHelper from pyqode_extras.widgets import FallbackCodeEdit _ = translation_context(u'OpenSesameIDE', category=u'extension') def with_editor_and_cursor(fnc): def inner(self, *args, **kwargs): editor = self._current_editor() if editor is None: return if takes_args: return fnc(self, editor, editor.textCursor(), *args, **kwargs) return fnc(self, editor, editor.textCursor()) takes_args = len(inspect.getargspec(fnc).args) > 3 return inner
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtWidgets from libopensesame.exceptions import osexception from libqtopensesame.items.experiment import experiment from libqtopensesame.widgets.base_widget import base_widget from libqtopensesame.misc.config import cfg from libqtopensesame.misc.translate import translation_context _ = translation_context(u'general_script_editor', category=u'core') class general_script_editor(base_widget): """ desc: The general script editor. """ def __init__(self, main_window): """ desc: Constructor. arguments:
(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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtWidgets from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc.translate import translation_context _ = translation_context(u'item_view_button', category=u'core') class item_view_button(base_subcomponent, QtWidgets.QPushButton): """ desc: The view button in the top-right of the edit controls. """ def __init__(self, item): """ desc: Constructor. arguments:
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame.logger import logger as logger_runtime from libqtopensesame.items.qtplugin import qtplugin from libqtopensesame.widgets.logger_widget import logger_widget from libqtopensesame.misc.translate import translation_context _ = translation_context(u'logger', category=u'item') class logger(logger_runtime, qtplugin): """ desc: GUI controls for the logger item. """ description = _(u'Logs experimental data') help_url = u'manual/logging' def __init__(self, name, experiment, string=None): """See item.""" logger_runtime.__init__(self, name, experiment, string)
You should have received a copy of the GNU General Public License along with OpenSesame. If not, see <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libqtopensesame.misc.config import cfg from datamatrix import DataMatrix from qdatamatrix import QDataMatrix from qtpy.QtWidgets import QDockWidget, QLabel from qtpy.QtGui import QFont from qtpy.QtCore import Qt, QTimer from libopensesame.oslogging import oslogger from libqtopensesame.extensions import BaseExtension from libqtopensesame.misc.translate import translation_context _ = translation_context(u'WorkspaceExplorer', category=u'extension') class WorkspaceMatrix(QDataMatrix): @property def cell_double_clicked(self): return self._spreadsheet.cellDoubleClicked class WorkspaceExplorer(BaseExtension): @BaseExtension.as_thread(wait=2500) def event_startup(self): dm = DataMatrix(length=0) dm.initializing = -1
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from variable_inspector_cell import variable_inspector_cell from libqtopensesame.widgets.base_widget import base_widget from libqtopensesame.misc import drag_and_drop from libqtopensesame.misc.translate import translation_context _ = translation_context(u'variable_inspector', category=u'extension') class variable_inspector_widget(base_widget): """ desc: The variable inspector widget, which includes the table, filter button, etc. """ def __init__(self, main_window, ext): """ desc: Constructor.
#-*- coding:utf-8 -*- """ This file is part of the Mousetrap plug-ins for OpenSesame. """ from libopensesame.py3compat import * from libopensesame import item, widgets from libqtopensesame.items.qtautoplugin import qtautoplugin from libopensesame.exceptions import osexception from libqtopensesame.misc.translate import translation_context _ = translation_context(u'mousetrap_form', category=u'plugins') # Import class for mouse button label conversion from libopensesame.mouse_response import mouse_response_mixin # Import mouse-tracking form from PyMT_form import MT_form # Define class for mouse-tracking plugin # Note that parts if this code are take from the code of the form_base plug-in class mousetrap_form(item.item, mouse_response_mixin): """Tracks mouse movements in custom form defined using OpenSesame script""" initial_view = u'controls' #initial_view = u'split' description = u'Tracks mouse movements in custom form defined using OpenSesame script' def reset(self): """ desc:
(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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libqtopensesame.extensions import base_extension from libqtopensesame.misc.config import cfg from libqtopensesame.misc.translate import translation_context _ = translation_context(u'opensesame_3_notifications', category=u'extension') class opensesame_3_notifications(base_extension): """ desc: Provides tips for new users of OpenSesame 3. """ def event_os3n_dismiss_startup(self): """ desc: Permanently disables the startup tab. """
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame import debug from qtpy import QtWidgets from libqtopensesame.widgets.general_header_widget import general_header_widget from libqtopensesame.widgets.base_widget import base_widget from openexp._color.color import color from openexp import backend from libqtopensesame.misc.translate import translation_context _ = translation_context(u'general_properties', category=u'core') class general_properties(base_widget): """The QWidget for the general properties tab.""" backend_format = u'%s [%s]' def __init__(self, main_window): """ desc: Constructor. arguments: main_window: A qtopensesame object. """
from libopensesame.py3compat import * from qtpy import QtGui, QtCore, QtWidgets from libqtopensesame.misc.base_component import base_component from libqtopensesame.misc.config import cfg from libqtopensesame.items import experiment from libopensesame import debug, metadata from libopensesame.exceptions import osexception import libopensesame.experiment import libopensesame.plugins import libopensesame.misc import os import sys import warnings from libqtopensesame.misc.translate import translation_context _ = translation_context(u'qtopensesame', category=u'core') class qtopensesame(QtWidgets.QMainWindow, base_component): """The main class of the OpenSesame GUI""" def __init__(self, app, parent=None): """ Constructor. This does very little, except prepare the app to be shown as rapidly as possible. The actual GUI initialization is handled by resume_init(). Arguments: app -- the QApplication Keyword arguments: parent -- a link to the parent window
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import os import math from openexp._color.color import color from libqtopensesame.misc import drag_and_drop from libqtopensesame.misc.config import cfg from qtpy import QtWidgets, QtGui, QtCore from libqtopensesame.misc.translate import translation_context _ = translation_context(u'sketchpad', category=u'item') class sketchpad_canvas(QtWidgets.QGraphicsScene): """ desc: A partial implementation of a canvas, so that sketchpad elements can draw to the canvas just as in runtime. """ def __init__(self, sketchpad): """ desc: constructor.
along with OpenSesame. If not, see <http://www.gnu.org/licenses/>. IMPORTANT NOTE: The parallel plug-in is not reliable, and will be replaced by the coroutines plugin. """ from libopensesame.py3compat import * import os.path import threading from libopensesame import sequence, debug from libqtopensesame.items import sequence as qtsequence from libqtopensesame.items import qtplugin try: from libqtopensesame.misc.translate import translation_context _ = translation_context(u'parallel', category=u'plugin') except ImportError: pass class parallel_process(threading.Thread): """A wrapper for a single process""" def __init__(self, item): """ Constructor Arguments: item -- the item to run """ threading.Thread.__init__(self)
from qtpy import QtWidgets from libopensesame import debug from libopensesame import metadata from libopensesame import misc from libqtopensesame.extensions import base_extension from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc.config import cfg from libopensesame.py3compat import * if py3: from urllib.request import urlopen else: from urllib2 import urlopen import yaml from libqtopensesame.misc.translate import translation_context _ = translation_context(u'help', category=u'extension') class action_page(QtWidgets.QAction, base_subcomponent): """ desc: A menu entry for a single help page. """ def __init__(self, main_window, title, link, menu): """ desc: Constructor. arguments:
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 <http://www.gnu.org/licenses/>. """ import os from qtpy import QtWidgets from libqtopensesame.misc.config import cfg from libopensesame import debug from libopensesame.exceptions import osexception from libopensesame.experiment import experiment from libopensesame.py3compat import * from libqtopensesame.misc.translate import translation_context _ = translation_context(u'base_runner', category=u'core') class base_runner(object): """ A runner implements a specific way to execute an OpenSesame experiment from within the GUI. The base_runner is an abstract runner that is inherited by actual runners. """ valid_logfile_extensions = u'.csv', u'.txt', u'.dat', u'.log' default_logfile_extension = u'.csv' def __init__(self, main_window): """
You should have received a copy of the GNU General Public License along with OpenSesame. If not, see <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qdatamatrix import QDataMatrix from pseudorandom import EnforceFailed from libopensesame.loop import loop as loop_runtime from libopensesame.exceptions import osexception from libqtopensesame.items.qtitem import qtitem from libqtopensesame.items.qtstructure_item import qtstructure_item from libqtopensesame.widgets.loop_widget import loop_widget from libqtopensesame.widgets.tree_item_item import tree_item_item from libqtopensesame.misc.translate import translation_context import math _ = translation_context(u'loop', category=u'item') class loop(qtstructure_item, qtitem, loop_runtime): """The GUI for the loop item""" description = _(u'Repeatedly runs another item') def __init__(self, name, experiment, string=None): """See qtitem.""" self.lock_cycles = False loop_runtime.__init__(self, name, experiment, string) qtitem.__init__(self)
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtWidgets from libopensesame import debug from libqtopensesame.extensions import base_extension from libqtopensesame.misc.config import cfg from libqtopensesame.misc.translate import translation_context _ = translation_context(u'update_checker', category=u'extension') class update_checker(base_extension): def activate(self): self.check_for_updates() def event_startup(self): self.check_for_updates(always=False) def check_for_updates(self, always=True): if py3: from urllib.request import urlopen
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from libopensesame import debug from libopensesame.inline_script import inline_script as inline_script_runtime from libqtopensesame.items.qtplugin import qtplugin from libqtopensesame.misc.config import cfg from libqtopensesame.widgets.tree_inline_script_item import \ tree_inline_script_item from libqtopensesame.misc.translate import translation_context _ = translation_context(u'inline_script', category=u'item') class inline_script(inline_script_runtime, qtplugin): """The inline_script GUI controls""" description = _(u'Executes Python code') help_url = u'manual/python/about' def __init__(self, name, experiment, string=None): """See item.""" inline_script_runtime.__init__(self, name, experiment, string) qtplugin.__init__(self) def apply_edit_changes(self):
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import os import re from qtpy.QtWidgets import QFileDialog from libqtopensesame.extensions import BaseExtension from libqtopensesame.misc.config import cfg from libqtopensesame.misc.translate import translation_context _ = translation_context(u'JupyterNotebook', category=u'extension') MARKDOWN_CELL = u'# <markdowncell>\n"""\n{}\n"""\n# </markdowncell>\n' CODE_CELL = u'# <codecell>\n{}\n# </codecell>\n' # Matches <codecell> ... </codecell> and <markdowncell> ... </markdowncell> NOTEBOOK_PATTERN = r'^#[ \t]*<(?P<cell_type>code|markdown)cell>[ \t]*\n(?P<source>.*?)\n^#[ \t]*</(code|markdown)cell>' # Matches # %% .. # %% SPYDER_PATTERN = r'((#[ \t]*%%[ \t]*\n)|\A)(?P<source>.*?)(\n|\Z)((?=#[ \t]*%%[ \t]*\n)|\Z)' # To check whether there any Spyder cells in there SPYDER_HAS_CELLS = r'#[ \t]*%%[ \t]*\n' class JupyterNotebook(BaseExtension): preferences_ui = 'extensions.JupyterNotebook.preferences'
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * from qtpy import QtCore, QtGui, QtWidgets from collections import OrderedDict from libopensesame import debug, plugins from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc.config import cfg from libqtopensesame.widgets.toolbar_items_label import toolbar_items_label from libqtopensesame.widgets.toolbar_items_item import toolbar_items_item from libqtopensesame.misc.translate import translation_context _ = translation_context(u'toolbar_items', category=u'core') class toolbar_items(base_subcomponent, QtWidgets.QToolBar): """ desc: The item toolbar, which allows you to insert items into the experiment through drag and drop. """ def __init__(self, parent): """ desc: Constructor.
#-*- coding:utf-8 -*- """ This file is part of the Mousetrap plug-ins for OpenSesame. """ from libopensesame.py3compat import * from libopensesame import item from libqtopensesame.items.qtautoplugin import qtautoplugin from libopensesame.exceptions import osexception from libqtopensesame.misc.translate import translation_context _ = translation_context(u'mousetrap_response', category=u'plugins') # Import class for mouse button label conversion from libopensesame.mouse_response import mouse_response_mixin # Import mouse-tracking response from PyMT_response import MT_response # Define class for mouse-tracking plugin class mousetrap_response(item.item, mouse_response_mixin): initial_view = u'controls' description = u'Tracks mouse movements' def reset(self): """ desc: Initialize plug-in. """ # Set default values for variables
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 <http://www.gnu.org/licenses/>. """ from libopensesame.py3compat import * import sys from qtpy import QtWidgets, QtCore from libopensesame import plugins from libopensesame.exceptions import osexception from libqtopensesame.misc.base_subcomponent import base_subcomponent from libqtopensesame.misc.translate import translation_context _ = translation_context(u'extension_manager', category=u'core') def suspend_events(fnc): """ desc: A decorator that causes all the extension manager to be suspended while the function is executed. """ def inner(self, *args, **kwdict): self.extension_manager.suspend() retval = fnc(self, *args, **kwdict) self.extension_manager.resume() return retval