def __init__(self, parent=None):
"""Parameters
----------
parent : QWidget
Parent widget
"""
super().__init__(parent)
self._ui = contClass()
self._ui.setupUi(self)
self._optionModels = [] # rescue from garbage collector
for name in list(algorithms.desc.keys()):
options_maker = algo_widget_dict.get(name)
if options_maker is None:
continue
o = options_maker()
o.optionsChanged.connect(self.optionsChanged)
self._ui.algorithmBox.addItem(name, o)
self._optionModels.append(o)
self._ui.saveButton.setIcon(QIcon.fromTheme("document-save-as"))
self._ui.loadButton.setIcon(QIcon.fromTheme("document-open"))
self._ui.saveButton.pressed.connect(self.save)
self._ui.loadButton.pressed.connect(self.load)
def update_progress(self, progress):
if not progress:
return
self.log.clear()
for entry in progress:
title, description, date, icon = entry
entry = EntryWidget()
entry.setTitle(title)
entry.setDescription(description)
entry.setDate(date)
entry.setIcon(QIcon.fromTheme(icon), self.iconsize)
if self.style_thresh:
if (int(date) < self.style_thresh):
entry.setStyle("color: lightgreen")
else:
entry.setStyle("color: lightsalmon")
item = QListWidgetItem(self.log)
item.setSizeHint(entry.sizeHint())
self.log.insertItem(0, item)
self.log.setItemWidget(item, entry)
def __init__(self, main_window, oswebext):
"""
desc:
Constructor.
arguments:
main_window: The main-window object.
"""
super(oswebext_widget,
self).__init__(main_window, ui=u'extensions.oswebext.oswebext')
self._oswebext = oswebext
self.ui.button_test.clicked.connect(self._test)
self.ui.fs_checkBox.toggled.connect(self._run_linter)
self.ui.button_jatos.clicked.connect(self._export_jatos)
self.ui.button_convert.clicked.connect(self._convert_results)
self.ui.plaintextedit_welcome_text.setPlainText(
safe_decode(cfg.oswebext_welcome_text))
self.ui.plaintextedit_welcome_text.textChanged.connect(
lambda: setattr(cfg, 'oswebext_welcome_text',
self.ui.plaintextedit_welcome_text.toPlainText()))
self.ui.plaintextedit_external_js.setPlainText(
safe_decode(cfg.oswebext_external_js))
self.ui.plaintextedit_external_js.textChanged.connect(
lambda: setattr(cfg, 'oswebext_external_js',
self.ui.plaintextedit_external_js.toPlainText()))
self.ui.label_version.setText(__version__)
self.ui.linedit_subject.setValidator(
QRegExpValidator(QRegExp("^(?:\d+(?:-\d+)?(?:,(?!$))?)+")))
self.ui.icon_expsize_warning.setPixmap(
QIcon.fromTheme('emblem-important').pixmap(32, 32))
self._init_widgets()
self._run_linter()
def get_application_icon(fpath):
"""Return application icon or default icon if not found."""
from qtpy.QtGui import QIcon
from spyder.utils import icon_manager as ima
if os.path.isfile(fpath) or os.path.isdir(fpath):
icon = ima.icon('no_match')
if sys.platform == 'darwin':
icon_path = _get_mac_application_icon_path(fpath)
if icon_path and os.path.isfile(icon_path):
icon = QIcon(icon_path)
elif os.name == 'nt':
pass
else:
entry_data = parse_linux_desktop_entry(fpath)
icon_path = entry_data['icon_path']
if icon_path:
if os.path.isfile(icon_path):
icon = QIcon(icon_path)
else:
icon = QIcon.fromTheme(icon_path)
else:
icon = ima.icon('help')
return icon
def __init__(self, env):
super().__init__()
self._env = env
self._extra_menu_actions = []
self._extra_toolbar_actions = []
self.update_title()
main_menu = self.menuBar()
self.main_menu = main_menu
project_menu = main_menu.addMenu("&Project")
toolbar = self.addToolBar("Top")
self.toolbar = toolbar
new_action = QAction("&New", self)
new_action.setShortcut("Ctrl+N")
new_action.setStatusTip("Create a new empty project")
new_action.triggered.connect(lambda: env.new())
project_menu.addAction(new_action)
open_action = QAction("&Open...", self)
open_action.setShortcut("Ctrl+O")
open_action.setStatusTip("Open an existing project")
open_action.triggered.connect(lambda: env.open())
project_menu.addAction(open_action)
save_action = QAction("&Save", self)
self.save_action = save_action
save_action.setShortcut("Ctrl+S")
save_action.setIcon(QIcon.fromTheme("document-save"))
#save_action.setIcon(self.style().standardIcon(
# self.style().SP_DialogSaveButton))
save_action.setStatusTip("Save project")
save_action.setEnabled(False)
save_action.triggered.connect(lambda: env.save())
project_menu.addAction(save_action)
toolbar.addAction(save_action)
save_as_action = QAction("Save &As...", self)
save_as_action.setStatusTip("Save project under a new name")
save_as_action.triggered.connect(lambda: env.save_as())
project_menu.addAction(save_as_action)
quit_action = QAction("&Quit", self)
quit_action.setShortcut("Ctrl+Q")
quit_action.setStatusTip("Quit Hildegard")
quit_action.triggered.connect(self.handle_quit)
project_menu.addAction(quit_action)
self.tabs = QTabWidget()
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(
lambda index: env.close(self.tabs.widget(index).entity, quit=True))
self.tabs.currentChanged.connect(self._handle_switch_to_tab)
self.setCentralWidget(self.tabs)
self.statusBar()
def __init__(self, parent=None):
super(MDIHistory, self).__init__(parent)
# name and widget handle for MDI cmd entry widget
self.mdi_entryline_name = None
self.mdi_entry_widget = None
# List order direction where Natural is latest at bottom.
# Default is Natural = False
self.mdi_listorder_natural = False
self.heart_beat_timer = None
self.icon_run_name = 'media-playback-start'
self.icon_run = QIcon.fromTheme(self.icon_run_name)
self.icon_waiting_name = 'media-playback-pause'
self.icon_waiting = QIcon.fromTheme(self.icon_waiting_name)
def on_debug_message(self, message):
msg = 'DEBUG - occurred at: [ {} ]\n{}'.format(
NotificationsWidget._get_time(),
NotificationsWidget._strip_new_line(message))
notification_item = QStandardItem()
notification_item.setText(msg)
notification_item.setIcon(QIcon.fromTheme('dialog-question'))
notification_item.setEditable(False)
self.all_notification_model.appendRow(notification_item)
def on_error_message(self, message):
msg = 'ERROR - occurred at: [ {} ]\n{}'.format(
NotificationsWidget._get_time(),
NotificationsWidget._strip_new_line(message))
LOG.debug('-----on_error_message called: {}'.format(message))
notification_item = QStandardItem()
notification_item.setText(msg)
notification_item.setIcon(QIcon.fromTheme('dialog-error'))
notification_item.setEditable(False)
self.all_notification_model.appendRow(notification_item)
def icon(self, ref):
if ref in self._icons:
icon_path = os.path.join(self._icon_dir, self._icons[ref])
return QIcon(icon_path)
else:
# By default, only X11 will support themed icons. In order to use
# themed icons on Mac and Windows, you will have to bundle a compliant
# theme in one of your PySide.QtGui.QIcon.themeSearchPaths() and set the
# appropriate PySide.QtGui.QIcon.themeName() .
return QIcon.fromTheme(ref)
def on_debug_message(self, message):
timestamp = time()
dt_object = datetime.fromtimestamp(timestamp)
current_time = str(dt_object)
msg = 'DEBUG\nTIME {}\n {}'.format(current_time, message)
notification_item = QStandardItem()
notification_item.setText(msg)
notification_item.setIcon(QIcon.fromTheme('dialog-question'))
notification_item.setEditable(False)
self.all_notification_model.appendRow(notification_item)
def addEntry(self, title, description, icon):
entry = EntryWidget()
entry.setTitle(title)
entry.setDescription(description)
entry.setDate("")
entry.setIcon(QIcon.fromTheme(icon))
item = QListWidgetItem(self.list)
item.setSizeHint(entry.sizeHint())
self.list.insertItem(0, item)
self.list.setItemWidget(item, entry)
return self.list.count()
def __init__(self, parent=None):
super().__init__(parent)
self._ui = fcClass()
self._ui.setupUi(self)
# if no parent is specified for the model, one gets strange errors
# about QTimer and QThreads when closing the application since it gets
# collected by python's garbage collector; see
# https://stackoverflow.com/questions/13562501
self._model = FileListModel(self)
self._ui.fileListView.setModel(self._model)
self._ui.addButton.setIcon(QIcon.fromTheme("document-open"))
self._ui.addButton.pressed.connect(self._addFilesSlot)
self._ui.removeButton.setIcon(QIcon.fromTheme("document-close"))
self._ui.removeButton.pressed.connect(self.removeSelected)
self._ui.fileListView.doubleClicked.connect(self.selected)
# install the event filter for handling key presses
self._kbdEventFilter = KbdEventFilter(self)
self._kbdEventFilter.enterPressed.connect(self.selected)
self._kbdEventFilter.delPressed.connect(self.removeSelected)
self._ui.fileListView.installEventFilter(self._kbdEventFilter)
def update_progress(self, progress):
if not progress:
return
title, description, date, icon = progress
entry = EntryWidget()
entry.setTitle(title)
entry.setDescription(description)
entry.setDate(date)
entry.setIcon(QIcon.fromTheme(icon))
item = QListWidgetItem(self.log)
item.setSizeHint(entry.sizeHint())
self.log.insertItem(0, item)
self.log.setItemWidget(item, entry)
def __init__(self, entity, env):
d = Diagram_Item(entity)
d.modified_callback = self.set_modified
super().__init__(d)
self.modified_callback = env.set_modified
self.entity = entity
show_ports_action = QAction("Connection Ports", self)
self._show_ports_action = show_ports_action
show_ports_action.setStatusTip("Show connection ports when hovering")
show_ports_action.setCheckable(True)
show_ports_action.setChecked(False)
show_ports_action.setIcon(QIcon.fromTheme("edit-find"))
show_ports_action.triggered.connect(
lambda x: d.set_show_connection_ports_on_hover(x))
self.view_menu.addAction(show_ports_action)
self.tools.append(show_ports_action)
def __init__(self, appdata: CnaData):
QWidget.__init__(self)
self.appdata = appdata
self.last_selected = None
self.reaction_counter = 1
self.add_button = QPushButton("Add new reaction")
self.add_button.setIcon(QIcon.fromTheme("list-add"))
policy = QSizePolicy()
policy.ShrinkFlag = True
self.add_button.setSizePolicy(policy)
self.reaction_list = DragableTreeWidget()
self.reaction_list.setDragEnabled(True)
self.reaction_list.setHeaderLabels(["Id", "Name", "Flux"])
self.reaction_list.setSortingEnabled(True)
for r in self.appdata.project.cobra_py_model.reactions:
self.add_reaction(r)
self.reaction_mask = ReactionMask(self)
self.reaction_mask.hide()
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
l = QHBoxLayout()
l.setAlignment(Qt.AlignRight)
l.addWidget(self.add_button)
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.splitter.addWidget(self.reaction_list)
self.splitter.addWidget(self.reaction_mask)
self.layout.addItem(l)
self.layout.addWidget(self.splitter)
self.setLayout(self.layout)
self.reaction_list.currentItemChanged.connect(self.reaction_selected)
self.reaction_mask.reactionChanged.connect(
self.handle_changed_reaction)
self.reaction_mask.reactionDeleted.connect(
self.handle_deleted_reaction)
self.reaction_mask.jumpToMap.connect(self.emit_jump_to_map)
self.reaction_mask.jumpToMetabolite.connect(
self.emit_jump_to_metabolite)
self.add_button.clicked.connect(self.add_new_reaction)
def __init__(self, redis, parent=None):
super(RedisTree, self).__init__(parent)
self.load_ui()
ui = self.ui
self.redis = redis
self.source_model = RedisKeyModel(redis)
self.sort_filter_model = QSortFilterProxyModel()
self.sort_filter_model.setFilterRole(KeyNameRole)
self.sort_filter_model.setSourceModel(self.source_model)
ui.tree.setModel(self.sort_filter_model)
selection = ui.tree.selectionModel()
selection.currentChanged.connect(self._on_current_changed)
selection.selectionChanged.connect(self._on_selection_changed)
# TODO: fix bug search of type "bl04:" still gives no result
ui.filter_container.setVisible(False)
add_menu = QMenu("Add")
ui.add_string_action = add_menu.addAction("string")
ui.add_list_action = add_menu.addAction("list")
ui.add_set_action = add_menu.addAction("set")
ui.add_hash_action = add_menu.addAction("hash")
add_button = QToolButton()
add_button.setMenu(add_menu)
add_button.setPopupMode(QToolButton.InstantPopup)
add_button.setIcon(QIcon.fromTheme("list-add"))
ui.add_key_action = ui.db_toolbar.insertWidget(ui.remove_key_action,
add_button)
ui.add_string_action.triggered.connect(
functools.partial(self._on_add_key, "string"))
ui.add_list_action.triggered.connect(
functools.partial(self._on_add_key, "list"))
ui.add_set_action.triggered.connect(
functools.partial(self._on_add_key, "set"))
ui.add_hash_action.triggered.connect(
functools.partial(self._on_add_key, "hash"))
ui.update_db_action.triggered.connect(self._on_update_db)
ui.flush_db_action.triggered.connect(self._on_flush_db)
ui.remove_key_action.triggered.connect(self._on_remove_key)
ui.touch_key_action.triggered.connect(self._on_touch_key)
ui.persist_key_action.triggered.connect(self._on_persist_key)
ui.copy_key_action.triggered.connect(self._on_copy_key)
ui.filter_edit.textChanged.connect(self._on_filter_changed)
def __init__(self, main_window, oswebext):
"""
desc:
Constructor.
arguments:
main_window: The main-window object.
"""
super(oswebext_widget,
self).__init__(main_window, ui=u'extensions.oswebext.oswebext')
self._oswebext = oswebext
self.ui.button_test.clicked.connect(self._test)
self.ui.button_jatos.clicked.connect(self._export_jatos)
self.ui.button_convert.clicked.connect(self._convert_results)
self.ui.label_version.setText(__version__)
self.ui.linedit_subject.setValidator(
QRegExpValidator(QRegExp("^(?:\d+(?:-\d+)?(?:,(?!$))?)+")))
self.ui.icon_expsize_warning.setPixmap(
QIcon.fromTheme('emblem-important').pixmap(32, 32))
self._run_linter()
def __init__(self, title, message, parent=None):
super(Message, self).__init__(parent)
self.setLayout(QGridLayout())
self.titleLabel = QLabel(title, self)
self.titleLabel.setStyleSheet("""
font-family: 'Roboto', sans-serif;
font-size: 14px; font-weight: bold;
padding: 0;
""")
self.messageLabel = QLabel(message, self)
self.messageLabel.setStyleSheet("""
font-family: 'Roboto', sans-serif;
font-size: 12px;
font-weight: normal;
padding: 0;
""")
self.buttonClose = QPushButton(self)
self.buttonClose.setIcon(QIcon.fromTheme("window-close"))
self.buttonClose.setFixedSize(32, 32)
self.layout().addWidget(self.titleLabel, 0, 0)
self.layout().addWidget(self.messageLabel, 1, 0)
self.layout().addWidget(self.buttonClose, 0, 1, 2, 1)
def __init__(self, appdata):
QWidget.__init__(self)
self.appdata = appdata
self.current = 0
self.scenario = {}
self.setFixedHeight(70)
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.clear_button = QPushButton()
self.clear_button.setIcon(QIcon.fromTheme("edit-delete"))
self.clear_button.setToolTip("clear modes")
self.prev_button = QPushButton("<")
self.next_button = QPushButton(">")
self.label = QLabel()
l1 = QHBoxLayout()
self.title = QLabel("Mode Navigation")
l12 = QHBoxLayout()
l12.setAlignment(Qt.AlignRight)
l12.addWidget(self.clear_button)
l1.addWidget(self.title)
l1.addLayout(l12)
l2 = QHBoxLayout()
l2.addWidget(self.prev_button)
l2.addWidget(self.label)
l2.addWidget(self.next_button)
self.layout.addLayout(l1)
self.layout.addLayout(l2)
self.setLayout(self.layout)
self.prev_button.clicked.connect(self.prev)
self.next_button.clicked.connect(self.next)
self.clear_button.clicked.connect(self.clear)
def setIcon(self, icon):
self.iconLabel.setPixmap(QIcon.fromTheme(icon).pixmap(QSize(128, 128)))
def __init__(self, parent=None):
super().__init__(parent)
self._ui = locSaveClass()
self._ui.setupUi(self)
self._ui.saveButton.setIcon(QIcon.fromTheme("document-save"))
def __init__(self, model):
"""Initialize MNELAB main window.
Parameters
----------
model : mnelab.model.Model instance
The main window needs to connect to a model containing all data
sets. This decouples the GUI from the data (model/view).
"""
super().__init__()
self.model = model # data model
self.setWindowTitle("MNELAB")
# restore settings
settings = read_settings()
self.recent = settings["recent"] # list of recent files
self.resize(settings["size"])
self.move(settings["pos"])
# trigger theme setting
QIcon.setThemeSearchPaths([str(Path(__file__).parent / "icons")])
self.event(QEvent(QEvent.PaletteChange))
self.actions = {} # contains all actions
# initialize menus
file_menu = self.menuBar().addMenu("&File")
icon = QIcon.fromTheme("open-file")
self.actions["open_file"] = file_menu.addAction(
icon, "&Open...", self.open_data, QKeySequence.Open)
self.recent_menu = file_menu.addMenu("Open recent")
self.recent_menu.aboutToShow.connect(self._update_recent_menu)
self.recent_menu.triggered.connect(self._load_recent)
if not self.recent:
self.recent_menu.setEnabled(False)
self.actions["close_file"] = file_menu.addAction(
"&Close",
self.model.remove_data,
QKeySequence.Close)
self.actions["close_all"] = file_menu.addAction(
"Close all",
self.close_all)
file_menu.addSeparator()
icon = QIcon.fromTheme("meta-info")
self.actions["meta_info"] = file_menu.addAction(icon,
"Show information...",
self.meta_info)
file_menu.addSeparator()
self.actions["import_bads"] = file_menu.addAction(
"Import bad channels...",
lambda: self.import_file(model.import_bads, "Import bad channels",
"*.csv"))
self.actions["import_events"] = file_menu.addAction(
"Import events...",
lambda: self.import_file(model.import_events, "Import events",
"*.csv"))
self.actions["import_annotations"] = file_menu.addAction(
"Import annotations...",
lambda: self.import_file(model.import_annotations,
"Import annotations", "*.csv"))
self.actions["import_ica"] = file_menu.addAction(
"Import &ICA...",
lambda: self.open_file(model.import_ica, "Import ICA",
"*.fif *.fif.gz"))
file_menu.addSeparator()
self.export_menu = file_menu.addMenu("Export data")
for ext, description in writers.items():
action = "export_data" + ext.replace(".", "_")
self.actions[action] = self.export_menu.addAction(
f"{ext[1:].upper()} ({description[1]})...",
partial(self.export_file, model.export_data, "Export data",
"*" + ext))
self.actions["export_bads"] = file_menu.addAction(
"Export &bad channels...",
lambda: self.export_file(model.export_bads, "Export bad channels",
"*.csv"))
self.actions["export_events"] = file_menu.addAction(
"Export &events...",
lambda: self.export_file(model.export_events, "Export events",
"*.csv"))
self.actions["export_annotations"] = file_menu.addAction(
"Export &annotations...",
lambda: self.export_file(model.export_annotations,
"Export annotations", "*.csv"))
self.actions["export_ica"] = file_menu.addAction(
"Export ICA...",
lambda: self.export_file(model.export_ica,
"Export ICA", "*.fif *.fif.gz"))
file_menu.addSeparator()
self.actions["quit"] = file_menu.addAction("&Quit", self.close,
QKeySequence.Quit)
edit_menu = self.menuBar().addMenu("&Edit")
self.actions["pick_chans"] = edit_menu.addAction(
"P&ick channels...",
self.pick_channels)
icon = QIcon.fromTheme("chan-props")
self.actions["chan_props"] = edit_menu.addAction(
icon, "Channel &properties...", self.channel_properties)
self.actions["set_montage"] = edit_menu.addAction("Set &montage...",
self.set_montage)
edit_menu.addSeparator()
self.actions["set_ref"] = edit_menu.addAction("Set &reference...",
self.set_reference)
edit_menu.addSeparator()
self.actions["annotations"] = edit_menu.addAction(
"&Annotations...",
self.edit_annotations)
self.actions["events"] = edit_menu.addAction("&Events...",
self.edit_events)
edit_menu.addSeparator()
self.actions["crop"] = edit_menu.addAction("&Crop data...", self.crop)
self.actions["append_data"] = edit_menu.addAction(
"Appen&d data...",
self.append_data)
plot_menu = self.menuBar().addMenu("&Plot")
icon = QIcon.fromTheme("plot-data")
self.actions["plot_data"] = plot_menu.addAction(icon, "&Data...",
self.plot_data)
icon = QIcon.fromTheme("plot-psd")
self.actions["plot_psd"] = plot_menu.addAction(
icon, "&Power spectral density...", self.plot_psd)
icon = QIcon.fromTheme("plot-locations")
self.actions["plot_locations"] = plot_menu.addAction(
icon, "&Channel locations...", self.plot_locations)
self.actions["plot_erds"] = plot_menu.addAction(
"&ERDS maps...", self.plot_erds)
plot_menu.addSeparator()
self.actions["plot_ica_components"] = plot_menu.addAction(
"ICA &components...", self.plot_ica_components)
self.actions["plot_ica_sources"] = plot_menu.addAction(
"ICA &sources...", self.plot_ica_sources)
tools_menu = self.menuBar().addMenu("&Tools")
icon = QIcon.fromTheme("filter-data")
self.actions["filter"] = tools_menu.addAction(icon, "&Filter data...",
self.filter_data)
icon = QIcon.fromTheme("find-events")
self.actions["find_events"] = tools_menu.addAction(icon,
"Find &events...",
self.find_events)
self.actions["events_from_annotations"] = tools_menu.addAction(
"Create events from annotations", self.events_from_annotations
)
self.actions["annotations_from_events"] = tools_menu.addAction(
"Create annotations from events", self.annotations_from_events
)
tools_menu.addSeparator()
nirs_menu = tools_menu.addMenu("NIRS")
self.actions["convert_od"] = nirs_menu.addAction(
"Convert to &optical density", self.convert_od)
self.actions["convert_bl"] = nirs_menu.addAction(
"Convert to &haemoglobin", self.convert_bl)
tools_menu.addSeparator()
icon = QIcon.fromTheme("run-ica")
self.actions["run_ica"] = tools_menu.addAction(icon, "Run &ICA...",
self.run_ica)
self.actions["apply_ica"] = tools_menu.addAction("Apply &ICA",
self.apply_ica)
tools_menu.addSeparator()
self.actions["interpolate_bads"] = tools_menu.addAction(
"Interpolate bad channels...",
self.interpolate_bads)
tools_menu.addSeparator()
icon = QIcon.fromTheme("epoch-data")
self.actions["epoch_data"] = tools_menu.addAction(
icon, "Create Epochs...", self.epoch_data)
view_menu = self.menuBar().addMenu("&View")
self.actions["history"] = view_menu.addAction("&History...",
self.show_history)
self.actions["toolbar"] = view_menu.addAction("&Toolbar",
self._toggle_toolbar)
self.actions["toolbar"].setCheckable(True)
self.actions["statusbar"] = view_menu.addAction("&Statusbar",
self._toggle_statusbar)
self.actions["statusbar"].setCheckable(True)
help_menu = self.menuBar().addMenu("&Help")
self.actions["about"] = help_menu.addAction("&About", self.show_about)
self.actions["about_qt"] = help_menu.addAction("About &Qt",
self.show_about_qt)
# actions that are always enabled
self.always_enabled = ["open_file", "about", "about_qt", "quit",
"toolbar", "statusbar"]
# set up toolbar
self.toolbar = self.addToolBar("toolbar")
self.toolbar.setObjectName("toolbar")
self.toolbar.addAction(self.actions["open_file"])
self.toolbar.addAction(self.actions["meta_info"])
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions["chan_props"])
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions["plot_data"])
self.toolbar.addAction(self.actions["plot_psd"])
self.toolbar.addAction(self.actions["plot_locations"])
self.toolbar.addSeparator()
self.toolbar.addAction(self.actions["filter"])
self.toolbar.addAction(self.actions["find_events"])
self.toolbar.addAction(self.actions["epoch_data"])
self.toolbar.addAction(self.actions["run_ica"])
self.setUnifiedTitleAndToolBarOnMac(True)
if settings["toolbar"]:
self.toolbar.show()
self.actions["toolbar"].setChecked(True)
else:
self.toolbar.hide()
self.actions["toolbar"].setChecked(False)
# set up data model for sidebar (list of open files)
self.names = QStringListModel()
self.names.dataChanged.connect(self._update_names)
splitter = QSplitter()
self.sidebar = QListView()
self.sidebar.setFrameStyle(QFrame.NoFrame)
self.sidebar.setFocusPolicy(Qt.NoFocus)
self.sidebar.setModel(self.names)
self.sidebar.clicked.connect(self._update_data)
splitter.addWidget(self.sidebar)
self.infowidget = InfoWidget()
splitter.addWidget(self.infowidget)
width = splitter.size().width()
splitter.setSizes((int(width * 0.3), int(width * 0.7)))
self.setCentralWidget(splitter)
self.status_label = QLabel()
self.statusBar().addPermanentWidget(self.status_label)
if settings["statusbar"]:
self.statusBar().show()
self.actions["statusbar"].setChecked(True)
else:
self.statusBar().hide()
self.actions["statusbar"].setChecked(False)
self.setAcceptDrops(True)
self.data_changed()
def get_icon(name, size=16):
"""Return QIcon from resources given name and, optional, size."""
return QIcon.fromTheme(name,
QIcon(":/icons/%ix%i/%s.png" % (size, size, name)))
def __init__(self, parent: ReactionList):
QWidget.__init__(self)
self.parent = parent
self.reaction = None
self.is_valid = True
self.changed = False
self.setAcceptDrops(False)
layout = QVBoxLayout()
l = QHBoxLayout()
self.delete_button = QPushButton("Delete reaction")
self.delete_button.setIcon(QIcon.fromTheme("edit-delete"))
policy = QSizePolicy()
policy.ShrinkFlag = True
self.delete_button.setSizePolicy(policy)
l.addWidget(self.delete_button)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Id:")
self.id = QLineEdit()
l.addWidget(label)
l.addWidget(self.id)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Name:")
self.name = QLineEdit()
l.addWidget(label)
l.addWidget(self.name)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Equation:")
self.equation = QLineEdit()
l.addWidget(label)
l.addWidget(self.equation)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate min:")
self.lower_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.lower_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate max:")
self.upper_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.upper_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Coefficient in obj. function:")
self.coefficent = QLineEdit()
l.addWidget(label)
l.addWidget(self.coefficent)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Gene reaction rule:")
self.gene_reaction_rule = QLineEdit()
l.addWidget(label)
l.addWidget(self.gene_reaction_rule)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Annotations:")
l.addWidget(label)
l2 = QHBoxLayout()
self.annotation = QTableWidget(0, 2)
self.annotation.setHorizontalHeaderLabels(
["key", "value"])
self.annotation.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
l2.addWidget(self.annotation)
self.add_anno = QPushButton("+")
self.add_anno.clicked.connect(self.add_anno_row)
l2.addWidget(self.add_anno)
l.addItem(l2)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Metabolites involved in this reaction:")
l.addWidget(label)
l2 = QHBoxLayout()
self.metabolites = QTreeWidget()
self.metabolites.setHeaderLabels(["Id"])
self.metabolites.setSortingEnabled(True)
l2.addWidget(self.metabolites)
l.addItem(l2)
self.metabolites.itemDoubleClicked.connect(
self.emit_jump_to_metabolite)
layout.addItem(l)
self.jump_list = JumpList(self)
layout.addWidget(self.jump_list)
self.setLayout(layout)
self.delete_button.clicked.connect(self.delete_reaction)
self.throttler = SignalThrottler(500)
self.throttler.triggered.connect(self.reaction_data_changed)
self.id.textEdited.connect(self.throttler.throttle)
self.name.textEdited.connect(self.throttler.throttle)
self.equation.textEdited.connect(self.throttler.throttle)
self.lower_bound.textEdited.connect(self.throttler.throttle)
self.upper_bound.textEdited.connect(self.throttler.throttle)
self.coefficent.textEdited.connect(self.throttler.throttle)
self.gene_reaction_rule.textEdited.connect(self.throttler.throttle)
self.annotation.itemChanged.connect(self.throttler.throttle)
self.validate_mask()
def _window_load_icons(self):
self._icons["help"] = QIcon.fromTheme("help")
self._icons["play"] = QIcon.fromTheme("play")
self._icons["pause"] = QIcon.fromTheme("pause")
self._icons["reset"] = QIcon.fromTheme("reset")
self._icons["scale"] = QIcon.fromTheme("scale")
self._icons["clear"] = QIcon.fromTheme("clear")
self._icons["movie"] = QIcon.fromTheme("movie")
self._icons["restore"] = QIcon.fromTheme("restore")
self._icons["screenshot"] = QIcon.fromTheme("screenshot")
self._icons["visibility_on"] = QIcon.fromTheme("visibility_on")
self._icons["visibility_off"] = QIcon.fromTheme("visibility_off")
self._icons["folder"] = QIcon.fromTheme("folder")
def __init__(self, parent=None):
super().__init__(parent)
# Go before setupUi for QMetaObject.connectSlotsByName to work
self._scene = MicroViewScene(self)
self._scene.setObjectName("scene")
self._ui = mvClass()
self._ui.setupUi(self)
self._ui.view.setScene(self._scene)
# Apparently this is necessary with Qt5, as otherwise updating fails
# on image change; there are white rectangles on the updated area
# until the mouse is moved in or out of the view
self._ui.view.setViewportUpdateMode(
QGraphicsView.BoundingRectViewportUpdate)
self._ui.view.setRenderHints(QPainter.Antialiasing)
self._scene.imageItem.signals.mouseMoved.connect(
self._updateCurrentPixelInfo)
self._imageData = np.array([])
self._intensityMin = None
self._intensityMax = None
self._sliderFactor = 1
self._ui.autoButton.pressed.connect(self.autoIntensity)
self._playing = False
self._playTimer = QTimer()
if not (qtpy.PYQT4 or qtpy.PYSIDE):
self._playTimer.setTimerType(Qt.PreciseTimer)
self._playTimer.setSingleShot(False)
# set up preview button
self._locEnabledStr = "Localizations are shown"
self._locDisabledStr = "Localizations are not shown"
self._ui.locButton.setToolTip(self.tr(self._locEnabledStr))
self._ui.locButton.toggled.connect(self.showLocalizationsChanged)
# connect signals and slots
self._ui.framenoBox.valueChanged.connect(self.selectFrame)
self._ui.playButton.pressed.connect(
lambda: self.setPlaying(not self._playing))
self._playTimer.timeout.connect(self.nextFrame)
self._ui.zoomInButton.pressed.connect(self.zoomIn)
self._ui.zoomOriginalButton.pressed.connect(self.zoomOriginal)
self._ui.zoomOutButton.pressed.connect(self.zoomOut)
self._ui.zoomFitButton.pressed.connect(self.zoomFit)
self._scene.roiChanged.connect(self.roiChanged)
# set button icons
self._ui.locButton.setIcon(QIcon.fromTheme("view-preview"))
self._ui.zoomOutButton.setIcon(QIcon.fromTheme("zoom-out"))
self._ui.zoomOriginalButton.setIcon(QIcon.fromTheme("zoom-original"))
self._ui.zoomFitButton.setIcon(QIcon.fromTheme("zoom-fit-best"))
self._ui.zoomInButton.setIcon(QIcon.fromTheme("zoom-in"))
self._ui.roiButton.setIcon(QIcon.fromTheme("draw-polygon"))
self._playIcon = QIcon.fromTheme("media-playback-start")
self._pauseIcon = QIcon.fromTheme("media-playback-pause")
self._ui.playButton.setIcon(self._playIcon)
# these are to be setEnable(False)'ed if there is no image sequence
self._noImsDisable = [
self._ui.zoomOutButton, self._ui.zoomOriginalButton,
self._ui.zoomFitButton, self._ui.zoomInButton, self._ui.roiButton,
self._ui.view, self._ui.pixelInfo, self._ui.frameSelector,
self._ui.contrastGroup
]
# initialize image data
self._locDataGood = None
self._locDataBad = None
self._locMarkers = None
self.setImageSequence(None)
def getIcon(name):
if not QIcon.hasThemeIcon(name):
warnings.warn('Unknown icon theme: %s' % name)
return QIcon()
return QIcon.fromTheme(name)
def __init__(self, item):
super().__init__()
self._shown = False
self.modified_callback = None
scene = QGraphicsScene()
self.scene = scene
self.scene_item = item
scene.addItem(item)
layout = QBoxLayout(QBoxLayout.TopToBottom, self)
scene_view = View(self)
self.scene_view = scene_view
scene_view.setScene(scene)
scene_view.setMinimumSize(350, 350)
scene_view.setRenderHint(QPainter.Antialiasing)
layout.addWidget(scene_view)
self.double_click_callback = None
self.mouse_press_callback = None
if hasattr(self.scene_item, "mouse_pressed_in"):
self.mouse_press_callback = self.scene_item.mouse_pressed_in
if hasattr(self.scene_item, "double_clicked_in_background"):
self.double_click_callback = \
self.scene_item.double_clicked_in_background
if hasattr(self.scene_item, "mouse_moved_in_scene"):
self.scene_view.mouse_move_callback = \
self.scene_item.mouse_moved_in_scene
self.menus = []
view_menu = QMenu("&View")
self.view_menu = view_menu
self.menus.append(view_menu)
export_menu = QMenu("&Export")
self.menus.append(export_menu)
self.tools = []
fit_action = QAction("&Fit", self)
fit_action.setShortcut("0")
fit_action.setIcon(QIcon.fromTheme("zoom-fit-best"))
fit_action.setStatusTip("Fit the entire scene to the viewport")
fit_action.triggered.connect(self.scene_view.fit_all_in_view)
view_menu.addAction(fit_action)
self.tools.append(fit_action)
reset_action = QAction("&Reset (1:1)", self)
reset_action.setShortcut("9")
reset_action.setIcon(QIcon.fromTheme("zoom-original"))
reset_action.setStatusTip("Reset the view to 100% scale")
reset_action.triggered.connect(self.scene_view.reset_scale)
view_menu.addAction(reset_action)
self.tools.append(reset_action)
zoom_in_action = QAction("Zoom &In", self)
zoom_in_action.setShortcuts(["+", "="])
zoom_in_action.setStatusTip("Zoom in")
zoom_in_action.triggered.connect(lambda: self.scene_view.zoom_in())
view_menu.addAction(zoom_in_action)
zoom_out_action = QAction("Zoom &Out", self)
zoom_out_action.setShortcuts(["-", "_"])
zoom_out_action.setStatusTip("Zoom out")
zoom_out_action.triggered.connect(lambda: self.scene_view.zoom_out())
view_menu.addAction(zoom_out_action)
export_svg_action = QAction("As &SVG...", self)
export_svg_action.setStatusTip("Export the current tab as an SVG file")
export_svg_action.triggered.connect(lambda: export_as_svg(self.scene))
export_menu.addAction(export_svg_action)
export_png_action = QAction("As PN&G...", self)
export_png_action.setStatusTip("Export the current tab as an PNG file")
export_png_action.triggered.connect(lambda: export_as_png(self.scene))
export_menu.addAction(export_png_action)
export_pdf_action = QAction("As &PDF...", self)
export_pdf_action.setStatusTip("Export the current tab as an PDF file")
export_pdf_action.triggered.connect(lambda: export_as_pdf(self.scene))
export_menu.addAction(export_pdf_action)
export_svg_clip_action = QAction("To Clipboard as SVG", self)
export_svg_clip_action.setStatusTip(
"Export the current tab to the clipoard in SVG format")
export_svg_clip_action.triggered.connect(
lambda: export_to_clipboard_as_svg(self.scene))
export_menu.addAction(export_svg_clip_action)
export_image_clip_action = QAction("To &Clipboard as Image", self)
export_image_clip_action.setStatusTip(
"Export the current tab to the clipoard as an image")
export_image_clip_action.triggered.connect(
lambda: export_to_clipboard_as_image(self.scene))
export_menu.addAction(export_image_clip_action)
self.resize(800, 600)
