class Ui_FilewriterCtrl(object):
def setupUi(self, FilewriterCtrl):
FilewriterCtrl.resize(649, 450)
broker_placeholder_text = "address:port/topic"
self.central_widget = QWidget(FilewriterCtrl)
self.vertical_layout_2 = QVBoxLayout(self.central_widget)
self.vertical_layout = QVBoxLayout()
self.horizontal_layout = QHBoxLayout()
self.horizontal_layout.setContentsMargins(-1, -1, 0, -1)
self.status_layout = QVBoxLayout()
self.status_layout.setContentsMargins(-1, -1, -1, 0)
self.status_topic_layout = QHBoxLayout()
self.status_topic_layout.setContentsMargins(-1, -1, -1, 0)
self.status_broker_label = QLabel(self.central_widget)
self.status_topic_layout.addWidget(self.status_broker_label)
self.status_broker_edit = QLineEdit(self.central_widget)
self.status_broker_edit.setPlaceholderText(broker_placeholder_text)
self.status_topic_layout.addWidget(self.status_broker_edit)
self.status_layout.addLayout(self.status_topic_layout)
self.line_2 = QFrame(self.central_widget)
self.line_2.setFrameShape(QFrame.HLine)
self.line_2.setFrameShadow(QFrame.Sunken)
self.status_layout.addWidget(self.line_2)
self.file_writer_table_group = QGroupBox(self.central_widget)
size_policy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(1)
size_policy.setHeightForWidth(
self.file_writer_table_group.sizePolicy().hasHeightForWidth())
self.file_writer_table_group.setSizePolicy(size_policy)
self.vertical_layout_4 = QVBoxLayout(self.file_writer_table_group)
self.vertical_layout_3 = QVBoxLayout()
self.file_writers_list = QTreeView(self.file_writer_table_group)
self.file_writers_list.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.file_writers_list.setIndentation(0)
self.vertical_layout_3.addWidget(self.file_writers_list)
self.vertical_layout_4.addLayout(self.vertical_layout_3)
self.status_layout.addWidget(self.file_writer_table_group)
self.files_group = QGroupBox(self.central_widget)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(4)
size_policy.setHeightForWidth(
self.files_group.sizePolicy().hasHeightForWidth())
self.files_group.setSizePolicy(size_policy)
self.vertical_layout_6 = QVBoxLayout(self.files_group)
self.files_list = QTreeView(self.files_group)
self.files_list.setIndentation(0)
self.vertical_layout_6.addWidget(self.files_list)
self.vertical_layout_5 = QVBoxLayout()
self.horizontal_layout_4 = QHBoxLayout()
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontal_layout_4.addItem(spacer)
self.stop_file_writing_button = QPushButton(self.files_group)
self.stop_file_writing_button.setEnabled(False)
self.horizontal_layout_4.addWidget(self.stop_file_writing_button)
self.vertical_layout_5.addLayout(self.horizontal_layout_4)
self.vertical_layout_6.addLayout(self.vertical_layout_5)
self.status_layout.addWidget(self.files_group)
self.horizontal_layout.addLayout(self.status_layout)
self.line = QFrame(self.central_widget)
self.line.setFrameShape(QFrame.VLine)
self.line.setFrameShadow(QFrame.Sunken)
self.horizontal_layout.addWidget(self.line)
self.command_layout = QVBoxLayout()
self.command_layout.setContentsMargins(-1, 0, -1, 0)
self.command_broker_layout = QHBoxLayout()
self.command_broker_label = QLabel(self.central_widget)
self.command_broker_layout.addWidget(self.command_broker_label)
self.command_broker_edit = QLineEdit(self.central_widget)
self.command_broker_edit.setPlaceholderText(broker_placeholder_text)
self.command_broker_layout.addWidget(self.command_broker_edit)
self.command_layout.addLayout(self.command_broker_layout)
self.command_widget = FilewriterCommandWidget(FilewriterCtrl)
self.command_layout.addWidget(self.command_widget)
self.horizontal_layout.addLayout(self.command_layout)
self.vertical_layout.addLayout(self.horizontal_layout)
self.vertical_layout_2.addLayout(self.vertical_layout)
FilewriterCtrl.setCentralWidget(self.central_widget)
self.status_broker_label.setText("Status broker")
self.file_writer_table_group.setTitle("File-writers")
self.files_group.setTitle("Files")
self.stop_file_writing_button.setText("Stop file-writing")
self.command_broker_label.setText("Command broker")
self.command_broker_edit.setPlaceholderText("address:port/topic")
QMetaObject.connectSlotsByName(FilewriterCtrl)
class ExportDialog(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.model = ExportChangesModel()
self.error_dialog = None
self.setWindowIcon(QIcon("paragon.ico"))
self.setWindowTitle("Export")
main_layout = QVBoxLayout(self)
self.export_button = QPushButton()
self.export_button.setText("Export")
self.main_view = QTreeView()
self.main_view.setModel(self.model)
self.main_view.setHeaderHidden(True)
self.main_view.setEditTriggers(
QtWidgets.QAbstractItemView.NoEditTriggers)
self.remember_selections_checkbox = QCheckBox()
self.remember_selections_checkbox.setText("Remember selections.")
main_layout.addWidget(self.export_button)
main_layout.addWidget(self.main_view)
main_layout.addWidget(self.remember_selections_checkbox)
self.setLayout(main_layout)
self.main_view.expanded.connect(self._on_item_expanded)
self.export_button.clicked.connect(self._on_export_triggered)
self.remember_selections_checkbox.stateChanged.connect(
self._on_remember_selections_state_changed)
self._set_remember_checkbox_state_from_settings()
def _set_remember_checkbox_state_from_settings(self):
settings_service = locator.get_static("SettingsService")
if settings_service.get_remember_exports():
self.remember_selections_checkbox.setCheckState(QtCore.Qt.Checked)
@staticmethod
def _on_remember_selections_state_changed(state: int):
should_remember = state == QtCore.Qt.Checked
locator.get_static("SettingsService").set_remember_exports(
should_remember)
def closeEvent(self, event: QtGui.QCloseEvent):
self.model.save_selected_items_tree()
event.accept()
def _on_export_triggered(self):
file_name, ok = QFileDialog.getSaveFileName(
self, caption="Select Changes File Destination", filter="*.json")
if ok:
self._try_export_and_write(file_name)
def _try_export_and_write(self, file_name):
logging.debug("Exporting selected data to %s" % file_name)
try:
export_data = self.model.export_selected_items()
with open(file_name, "w", encoding="utf-8") as f:
json.dump(export_data, f, indent=4, ensure_ascii=False)
except:
logging.exception("An error occurred while exporting data.")
self.error_dialog = ErrorDialog(
"An error occurred while exporting. See the log for details.")
self.error_dialog.show()
def _on_item_expanded(self, index: QModelIndex):
self.model.update_data_for_index(index)
class MVCConfigurationGUI(MVCConfigurationBase):
"""
GUI implementation of MVCConfigurationBase
"""
def __init__(self, configuration):
super().__init__(configuration)
assertMainThread()
srv = Services.getService("MainWindow")
srv.aboutToClose.connect(self._aboutToClose)
confMenu = srv.menuBar().addMenu("&Configuration")
toolBar = srv.getToolBar()
configuration.configNameChanged.connect(self._configNameChanged)
configuration.dirtyChanged.connect(self._dirtyChanged)
style = QApplication.style()
self.actLoad = QAction(
QIcon.fromTheme("document-open",
style.standardIcon(QStyle.SP_DialogOpenButton)),
"Open config", self)
self.actLoad.triggered.connect(self._execLoad)
self.actSave = QAction(
QIcon.fromTheme("document-save",
style.standardIcon(QStyle.SP_DialogSaveButton)),
"Save config", self)
self.actSave.triggered.connect(self._execSaveConfig)
self.actSaveWithGuiState = QAction(
QIcon.fromTheme("document-save",
style.standardIcon(QStyle.SP_DialogSaveButton)),
"Save config sync gui state", self)
self.actSaveWithGuiState.triggered.connect(
self._execSaveConfigWithGuiState)
self.actNew = QAction(
QIcon.fromTheme("document-new",
style.standardIcon(QStyle.SP_FileIcon)),
"New config", self)
self.actNew.triggered.connect(self._execNew)
self.actActivate = QAction(
QIcon.fromTheme("arrow-up", style.standardIcon(QStyle.SP_ArrowUp)),
"Initialize", self)
self.actActivate.triggered.connect(self.activate)
self.actDeactivate = QAction(
QIcon.fromTheme("arrow-down",
style.standardIcon(QStyle.SP_ArrowDown)),
"Deinitialize", self)
self.actDeactivate.triggered.connect(self.deactivate)
confMenu.addAction(self.actLoad)
confMenu.addAction(self.actSave)
confMenu.addAction(self.actSaveWithGuiState)
confMenu.addAction(self.actNew)
confMenu.addAction(self.actActivate)
confMenu.addAction(self.actDeactivate)
toolBar.addAction(self.actLoad)
toolBar.addAction(self.actSave)
toolBar.addAction(self.actNew)
toolBar.addAction(self.actActivate)
toolBar.addAction(self.actDeactivate)
self.recentConfigs = [QAction() for i in range(10)]
self.recentConfigs[0].setShortcut(QKeySequence(Qt.CTRL + Qt.Key_R))
confMenu.addSeparator()
recentMenu = confMenu.addMenu("Recent")
for a in self.recentConfigs:
a.setVisible(False)
a.triggered.connect(self._openRecent)
recentMenu.addAction(a)
self.mainWidget = srv.newDockWidget("Configuration", None,
Qt.LeftDockWidgetArea)
self.treeView = QTreeView(self.mainWidget)
self.treeView.setHeaderHidden(False)
self.treeView.setSelectionMode(QAbstractItemView.NoSelection)
self.treeView.setEditTriggers(self.treeView.EditKeyPressed
| self.treeView.AnyKeyPressed)
self.treeView.setAllColumnsShowFocus(True)
self.treeView.setExpandsOnDoubleClick(False)
self.treeView.setDragEnabled(True)
self.treeView.setDropIndicatorShown(True)
self.treeView.setDragDropMode(QAbstractItemView.DragOnly)
self.mainWidget.setWidget(self.treeView)
self.treeView.setModel(self.model)
self.treeView.header().setStretchLastSection(True)
self.treeView.header().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.treeView.doubleClicked.connect(self._onItemDoubleClicked)
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(
self._execTreeViewContextMenu)
# expand applications by default
self.treeView.setExpanded(self.model.index(1, 0), True)
self.delegate = PropertyDelegate(self.model, ITEM_ROLE,
ConfigurationModel.PropertyContent,
self)
self.treeView.setItemDelegate(self.delegate)
self.restoreState()
srv.aboutToClose.connect(self.saveState)
# a list of dock widgets displaying subgraphs
self._graphViews = []
# make sure that the graph views are closed when the config is closed
self._configuration.subConfigRemoved.connect(self._subConfigRemoved)
self._waitForActivated = None
self._waitForOpenState = None
def _execLoad(self):
assertMainThread()
if self._checkDirty():
return
fn, _ = QFileDialog.getOpenFileName(self.mainWidget,
"Load configuration",
self.cfgfile,
filter="*.json")
if fn is not None and fn != "":
logger.debug("Loading config file %s", fn)
try:
self.loadConfig(fn)
except Exception as e: # pylint: disable=broad-except
logger.exception("Error while loading configuration %s: %s",
fn, str(e))
QMessageBox.warning(self.mainWidget,
"Error while loading configuration",
str(e))
def _openRecent(self):
"""
Called when the user clicks on a recent config.
:return:
"""
if self._checkDirty():
return
action = self.sender()
fn = action.data()
try:
self.loadConfig(fn)
except Exception as e: # pylint: disable=broad-except
# catching general exception is wanted here.
logger.exception("Error while loading configuration %s: %s", fn,
str(e))
QMessageBox.warning(self.mainWidget,
"Error while loading configuration", str(e))
def _checkDirty(self):
if self._configuration.dirty():
ans = QMessageBox.question(
None,
"Save changes?",
"There are unsaved changes. Do you want to save them?",
buttons=QMessageBox.Save | QMessageBox.Discard
| QMessageBox.Cancel,
defaultButton=QMessageBox.Save)
if ans == QMessageBox.Save:
self.saveConfig()
return False
if ans == QMessageBox.Cancel:
return True
return False
def _aboutToClose(self, mainWindow):
if self._checkDirty():
mainWindow.ignoreCloseEvent()
def _execNew(self):
assertMainThread()
if self._checkDirty():
return
fn, _ = QFileDialog.getSaveFileName(self.mainWidget,
"New configuration",
".",
filter="*.json")
if fn is not None and fn != "":
logger.debug("Creating config file %s", fn)
self.newConfig(fn)
def _execSaveConfig(self):
if self.configuration().filename() is None:
self._execSaveConfigAs()
else:
self.saveConfig()
def _execSaveConfigWithGuiState(self):
if self.configuration().filename() is None:
self._execSaveConfigAs()
else:
self.saveConfigWithGuiState()
def _execSaveConfigAs(self):
"""
Opens a file dialog to get the save file name and calls saveConfig.
:return:
"""
assertMainThread()
fn, _ = QFileDialog.getSaveFileName(self.mainWidget,
"Save configuration as", ".",
"*.json")
if fn is not None and fn != "":
self.saveConfigAs(fn)
def _addGraphView(self, subConfig):
g = subConfig.getGraph()
# remove already deleted graph views from internal list
valid_graphViews = []
for gv in self._graphViews:
if shiboken2.isValid(gv): # pylint: disable=no-member
valid_graphViews.append(gv)
self._graphViews = valid_graphViews
# check if graph view is already there
for gv in self._graphViews:
if gv.widget().scene().graph == g:
logger.info("Graph view already exists.")
return
# create new graph view
srv = Services.getService("MainWindow")
graphDw = srv.newDockWidget("Graph (%s)" % (subConfig.getName()),
parent=None,
defaultArea=Qt.RightDockWidgetArea,
allowedArea=Qt.RightDockWidgetArea
| Qt.BottomDockWidgetArea)
graphDw.setAttribute(Qt.WA_DeleteOnClose, True)
assert isinstance(graphDw, QDockWidget)
graphView = GraphEditorView(graphDw)
graphView.setScene(GraphScene(subConfig.getGraph(), graphDw))
graphDw.setWidget(graphView)
self._graphViews.append(graphDw)
graphDw.visibleChanged.connect(self._removeGraphViewFromList)
def _subConfigRemoved(self, subConfigName, configType):
g = self._configuration.subConfigByNameAndTye(subConfigName,
configType).getGraph()
for gv in self._graphViews:
if gv.widget().scene().graph == g:
logger.debug("deleting graph view for subconfig %s",
subConfigName)
gv.deleteLater()
def _removeGraphViewFromList(self, visible):
if visible:
return
gv = self.sender()
try:
self._graphViews.remove(gv)
logger.debug("removed graphview from list")
except ValueError:
logger.debug("graphview not in list, ignored")
def _execTreeViewContextMenu(self, point):
index = self.treeView.indexAt(point)
item = self.model.data(index, ITEM_ROLE)
if isinstance(item, ConfigurationModel.SubConfigContent):
m = QMenu()
a1 = QAction("Edit graph")
m.addAction(a1)
a1.triggered.connect(lambda: self._addGraphView(item.subConfig))
if self.model.isApplication(index):
a2 = QAction("Select Application")
a2.triggered.connect(lambda: self.changeActiveApp(
self.model.data(index, Qt.DisplayRole)))
a3 = QAction("Init Application")
a3.triggered.connect(lambda: self._changeActiveAppAndInit(
self.model.data(index, Qt.DisplayRole)))
m.addActions([a2, a3])
pbsrv = Services.getService("PlaybackControl")
m2 = m.addMenu("Init and load sequence")
m3 = m.addMenu("Init, load and play")
s1 = []
s2 = []
for a in pbsrv.recentSeqs:
assert isinstance(a, QAction)
if a.isVisible():
# pylint: disable=cell-var-from-loop
# the below statements are tested and work
aseq = QAction(a.text())
aseq.triggered.connect(lambda arg1=a.data(
), seq=a.data(): self._changeActiveAppInitAndLoad(
self.model.data(index, Qt.DisplayRole), seq, False)
)
s1.append(aseq)
aseq = QAction(a.text())
aseq.triggered.connect(lambda arg1=a.data(
), seq=a.data(): self._changeActiveAppInitAndLoad(
self.model.data(index, Qt.DisplayRole), seq, True))
# pylint: enable=cell-var-from-loop
s2.append(aseq)
m2.addActions(s1)
m3.addActions(s2)
m.exec_(self.treeView.mapToGlobal(point))
return
if self.model.isSubConfigParent(
index) == Configuration.CONFIG_TYPE_APPLICATION:
m = QMenu()
a = QAction("Add application")
m.addAction(a)
a = m.exec_(self.treeView.mapToGlobal(point))
if a is not None:
self._configuration.addNewApplication()
return
if self.model.isSubConfigParent(
index) == Configuration.CONFIG_TYPE_COMPOSITE:
m = QMenu()
a = QAction("Add composite filter")
m.addAction(a)
a = m.exec_(self.treeView.mapToGlobal(point))
if a is not None:
self._configuration.addNewCompositeFilter()
return
def _configNameChanged(self, cfgfile):
logger.debug("_configNameChanged: %s", cfgfile)
assertMainThread()
self.cfgfile = cfgfile
self._dirtyChanged(self._configuration.dirty())
foundIdx = None
for i, a in enumerate(self.recentConfigs):
if a.data() == cfgfile:
foundIdx = i
if foundIdx is None:
foundIdx = len(self.recentConfigs) - 1
for i in range(foundIdx, 0, -1):
self.recentConfigs[i].setText(self.recentConfigs[i - 1].text())
self.recentConfigs[i].setData(self.recentConfigs[i - 1].data())
self.recentConfigs[i].setVisible(
self.recentConfigs[i - 1].data() is not None)
self.recentConfigs[0].setText(cfgfile)
self.recentConfigs[0].setData(cfgfile)
self.recentConfigs[0].setVisible(True)
def _dirtyChanged(self, dirty):
srv = Services.getService("MainWindow")
if self.cfgfile is None:
title = "nexxT: <unnamed>"
else:
title = "nexxT: " + self.cfgfile
if dirty:
title += " *"
srv.setWindowTitle(title)
def _onItemDoubleClicked(self, index):
assertMainThread()
if self.model.isApplication(index):
app = self.model.data(index, Qt.DisplayRole)
self.changeActiveApp(app)
else:
self.treeView.edit(index)
def _changeActiveAppAndInit(self, app):
"""
Call this slot to activate and init an application
:param app: can be either an Application instance or the name of an application
:return:
"""
assertMainThread()
if isinstance(app, str):
app = self.configuration().applicationByName(app)
currentApp = Application.activeApplication
if currentApp is not None:
currentApp = currentApp.getApplication()
self._waitForActivated = app
self.changeActiveApp(app.getName())
def _changeActiveAppInitAndLoad(self, app, sequence, startPlay):
self._waitForOpenState = (app, sequence, startPlay)
self._changeActiveAppAndInit(app)
def appActivated(self, name, app): # pylint: disable=unused-argument
"""
Called when the application is activated.
:param name: the application name
:param app: An ActiveApplication instance.
:return:
"""
assertMainThread()
if app is not None:
self.activeAppStateChange(app.getState())
app.stateChanged.connect(self.activeAppStateChange)
if self._waitForActivated == app.getApplication():
MethodInvoker(self.activate, Qt.QueuedConnection)
else:
self.actActivate.setEnabled(False)
self.actDeactivate.setEnabled(False)
self._waitForActivated = None
def _disconnectSingleShotPlay(self):
assertMainThread()
pbsrv = Services.getService("PlaybackControl")
try:
pbsrv.playbackPaused.disconnect(self._singleShotPlay)
except RuntimeError:
# we are already disconnected.
pass
def _singleShotPlay(self):
assertMainThread()
pbsrv = Services.getService("PlaybackControl")
MethodInvoker(pbsrv.startPlayback, Qt.QueuedConnection)
self._disconnectSingleShotPlay()
def activeAppStateChange(self, newState):
"""
Called when the active application changes its state.
:param newState: the new application's state (see FilterState)
:return:
"""
assertMainThread()
if newState == FilterState.CONSTRUCTED:
self.actActivate.setEnabled(True)
else:
self.actActivate.setEnabled(False)
if newState == FilterState.ACTIVE:
if self._waitForOpenState is not None:
app, pbfile, startPlay = self._waitForOpenState
self._waitForOpenState = None
if app == Application.activeApplication.getApplication(
).getName():
pbsrv = Services.getService("PlaybackControl")
if startPlay:
pbsrv.playbackPaused.connect(self._singleShotPlay)
QTimer.singleShot(2000, self._disconnectSingleShotPlay)
MethodInvoker(pbsrv.browser.setActive, Qt.QueuedConnection,
pbfile)
self.actDeactivate.setEnabled(True)
self.actSaveWithGuiState.setEnabled(False)
else:
self.actDeactivate.setEnabled(False)
self.actSaveWithGuiState.setEnabled(True)
def restoreState(self):
"""
Restore the state of the configuration gui service (namely the recently
open config files). This is saved in QSettings because it is used
across config files.
:return:
"""
logger.debug("restoring config state ...")
settings = QSettings()
v = settings.value("ConfigurationRecentFiles")
if v is not None and isinstance(v, QByteArray):
ds = QDataStream(v)
recentFiles = ds.readQStringList()
idx = 0
for f in recentFiles:
if f != "" and f is not None:
self.recentConfigs[idx].setData(f)
self.recentConfigs[idx].setText(f)
self.recentConfigs[idx].setVisible(True)
idx += 1
if idx >= len(self.recentConfigs):
break
logger.debug("restoring config state done")
def saveState(self):
"""
Save the state of the configuration gui service (namely the recently
open config files). This is saved in QSettings because it is used
across config files.
:return:
"""
logger.debug("saving config state ...")
settings = QSettings()
b = QByteArray()
ds = QDataStream(b, QIODevice.WriteOnly)
l = [
rc.data() for rc in self.recentConfigs
if rc.isVisible() and rc.data() is not None and rc.data() != ""
]
ds.writeQStringList(l)
settings.setValue("ConfigurationRecentFiles", b)
logger.debug("saving config state done (%s)", l)
def import_accounts_dialog(self):
self.import_accounts_window.setWindowTitle(_("Import accounts"))
self.import_accounts_window.setWindowIcon(self.switcher_logo)
self.import_accounts_window.setMinimumWidth(400)
layout = QVBoxLayout()
self.import_accounts_window.setLayout(layout)
text_label = QLabel(_("Select accounts to import"))
import_accounts_list = QTreeView()
import_button = QPushButton()
model = QStandardItemModel()
model.setHorizontalHeaderLabels(
[_('Login name'), _('Steam name'),
_('Steam UID')])
import_accounts_list.setModel(model)
import_accounts_list.setUniformRowHeights(True)
import_accounts_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
import_accounts_list.setSelectionMode(QTreeView.MultiSelection)
layout.addWidget(text_label)
layout.addWidget(import_accounts_list)
layout.addWidget(import_button)
installed_accounts = self.switcher.settings.get("users").keys()
disabled = []
for uid, steam_user in self.switcher.load_loginusers().items():
account_row = [
QStandardItem(steam_user.get("AccountName")),
QStandardItem(steam_user.get("PersonaName")),
QStandardItem(uid)
]
# account_row[0].setCheckable(True)
account_row[2].setEnabled(False)
if steam_user.get("AccountName") in installed_accounts:
# account_row = [ x.setEnabled(False) for x in account_row]
disabled.append(account_row)
else:
model.appendRow(account_row)
# model.appendRows(disabled) #Existing accounts grayed out
import_accounts_list.resizeColumnToContents(0)
def import_accounts():
selected_accounts = import_accounts_list.selectionModel(
).selectedRows()
for account in selected_accounts:
self.switcher.add_account(account.data(0))
self.steamapi_refresh()
self.import_accounts_window.hide()
def button_enabled():
num_selected = len(
import_accounts_list.selectionModel().selectedRows())
import_button.setText(
_("Import {0} accounts").format(num_selected))
if num_selected:
import_button.setEnabled(True)
else:
import_button.setEnabled(False)
button_enabled()
import_accounts_list.selectionModel().selectionChanged.connect(
button_enabled)
import_button.clicked.connect(import_accounts)
self.import_accounts_window.show()